diff --git a/src/Nest/.gitignore b/src/Nest/.gitignore deleted file mode 100644 index 74732854d52..00000000000 --- a/src/Nest/.gitignore +++ /dev/null @@ -1,2 +0,0 @@ - -*.ncrunchproject \ No newline at end of file diff --git a/src/Nest/DSL/CreateIndexDescriptor.cs b/src/Nest/DSL/CreateIndexDescriptor.cs index b564ec62c78..b9046d72db8 100644 --- a/src/Nest/DSL/CreateIndexDescriptor.cs +++ b/src/Nest/DSL/CreateIndexDescriptor.cs @@ -185,7 +185,14 @@ public CreateIndexDescriptor Analysis(Func similaritySelector) + { + similaritySelector.ThrowIfNull("similaritySelector"); + var similarity = similaritySelector(new SimilarityDescriptor(this._IndexSettings.Similarity)); + this._IndexSettings.Similarity = similarity == null ? null : similarity._SimilaritySettings; + return this; + } protected override void UpdatePathInfo(IConnectionSettingsValues settings, ElasticsearchPathInfo pathInfo) { diff --git a/src/Nest/DSL/SimilarityDescriptor.cs b/src/Nest/DSL/SimilarityDescriptor.cs new file mode 100644 index 00000000000..814407a28d3 --- /dev/null +++ b/src/Nest/DSL/SimilarityDescriptor.cs @@ -0,0 +1,38 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace Nest +{ + public class SimilarityDescriptor + { + internal readonly SimilaritySettings _SimilaritySettings; + + public SimilarityDescriptor() + { + this._SimilaritySettings = new SimilaritySettings(); + } + + public SimilarityDescriptor(SimilaritySettings settings) + { + this._SimilaritySettings = settings; + } + + public SimilarityDescriptor CustomSimilarities( + Func, FluentDictionary> similaritySelector) + { + similaritySelector.ThrowIfNull("similaritySelector"); + var similarities = new FluentDictionary(this._SimilaritySettings.CustomSimilarities); + var newSimilarities = similaritySelector(similarities); + this._SimilaritySettings.CustomSimilarities = newSimilarities; + return this; + } + + public SimilarityDescriptor Default(string defaultSimilarity) + { + this._SimilaritySettings.Default = defaultSimilarity; + return this; + } + } +} diff --git a/src/Nest/Domain/Settings/CustomSimilaritySettings.cs b/src/Nest/Domain/Settings/CustomSimilaritySettings.cs deleted file mode 100644 index c8edfbebe89..00000000000 --- a/src/Nest/Domain/Settings/CustomSimilaritySettings.cs +++ /dev/null @@ -1,23 +0,0 @@ -using Newtonsoft.Json; - -namespace Nest.Domain.Settings -{ - using System.Collections.Generic; - - public class CustomSimilaritySettings - { - public string Name { get; private set; } - public string Type { get; private set; } - [JsonConverter(typeof(DictionaryKeysAreNotPropertyNamesJsonConverter))] - public Dictionary SimilarityParameters { get; private set; } - - public CustomSimilaritySettings(string name, string type) - { - Name = name; - Type = type; - - SimilarityParameters = new Dictionary(); - } - - } -} diff --git a/src/Nest/Domain/Settings/IndexSettings.cs b/src/Nest/Domain/Settings/IndexSettings.cs index 838bccb4f15..0cd796dcdd5 100644 --- a/src/Nest/Domain/Settings/IndexSettings.cs +++ b/src/Nest/Domain/Settings/IndexSettings.cs @@ -16,6 +16,7 @@ public class IndexSettings public IndexSettings() { this.Analysis = new AnalysisSettings(); + this.Similarity = new SimilaritySettings(); this.Mappings = new List(); this.Warmers = new Dictionary(); this.Settings = new Dictionary(); @@ -59,7 +60,7 @@ public int? NumberOfShards [JsonConverter(typeof(DictionaryKeysAreNotPropertyNamesJsonConverter))] public Dictionary Warmers { get; internal set; } - public SimilaritySettings Similarity { get; set; } + public SimilaritySettings Similarity { get; internal set; } } diff --git a/src/Nest/Domain/Settings/SimilaritySettings.cs b/src/Nest/Domain/Settings/SimilaritySettings.cs deleted file mode 100644 index af2f6d85c06..00000000000 --- a/src/Nest/Domain/Settings/SimilaritySettings.cs +++ /dev/null @@ -1,24 +0,0 @@ -using System; -using System.Collections.Generic; - -namespace Nest -{ - using Nest.Domain.Settings; - - public class SimilaritySettings - { - public string BaseSimilarity { get; private set; } - - public List CustomSimilarities { get; private set; } - - public SimilaritySettings() - { - CustomSimilarities = new List(); - } - - public SimilaritySettings(string baseSimilarity) : this() - { - BaseSimilarity = baseSimilarity; - } - } -} diff --git a/src/Nest/Domain/Similarity/BM25Similarity.cs b/src/Nest/Domain/Similarity/BM25Similarity.cs new file mode 100644 index 00000000000..c4c24d9c24f --- /dev/null +++ b/src/Nest/Domain/Similarity/BM25Similarity.cs @@ -0,0 +1,25 @@ +using Newtonsoft.Json; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace Nest +{ + public class BM25Similarity : SimilarityBase + { + public BM25Similarity() + { + this.Type = "BM25"; + } + + [JsonProperty("k1")] + public double K1 { get; set; } + + [JsonProperty("b")] + public double B { get; set; } + + [JsonProperty("discount_overlaps")] + public bool DiscountOverlaps { get; set; } + } +} diff --git a/src/Nest/Domain/Similarity/DFRSimilarity.cs b/src/Nest/Domain/Similarity/DFRSimilarity.cs new file mode 100644 index 00000000000..4c9ddb902f7 --- /dev/null +++ b/src/Nest/Domain/Similarity/DFRSimilarity.cs @@ -0,0 +1,22 @@ +using Newtonsoft.Json; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace Nest +{ + public class DFRSimilarity : SimilarityBase + { + public DFRSimilarity() + { + this.Type = "DFR"; + } + + [JsonProperty("basic_model")] + public string BasicModel { get; set; } + + [JsonProperty("after_effect")] + public string AfterEffect { get; set; } + } +} \ No newline at end of file diff --git a/src/Nest/Domain/Similarity/DefaultSimilarity.cs b/src/Nest/Domain/Similarity/DefaultSimilarity.cs new file mode 100644 index 00000000000..bf915cc1dcd --- /dev/null +++ b/src/Nest/Domain/Similarity/DefaultSimilarity.cs @@ -0,0 +1,19 @@ +using Newtonsoft.Json; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace Nest +{ + public class DefaultSimilarity : SimilarityBase + { + public DefaultSimilarity() + { + this.Type = "default"; + } + + [JsonProperty("discount_overlaps")] + public bool DiscountOverlaps { get; set; } + } +} diff --git a/src/Nest/Domain/Similarity/IBSimilarity.cs b/src/Nest/Domain/Similarity/IBSimilarity.cs new file mode 100644 index 00000000000..d15493e1dbb --- /dev/null +++ b/src/Nest/Domain/Similarity/IBSimilarity.cs @@ -0,0 +1,22 @@ +using Newtonsoft.Json; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace Nest +{ + public class IBSimilarity : SimilarityBase + { + public IBSimilarity() + { + this.Type = "IB"; + } + + [JsonProperty("distribution")] + public string Distribution { get; set; } + + [JsonProperty("lambda")] + public string Lambda { get; set; } + } +} diff --git a/src/Nest/Domain/Similarity/LMDirichletSimilarity.cs b/src/Nest/Domain/Similarity/LMDirichletSimilarity.cs new file mode 100644 index 00000000000..0e3d59bcaa2 --- /dev/null +++ b/src/Nest/Domain/Similarity/LMDirichletSimilarity.cs @@ -0,0 +1,19 @@ +using Newtonsoft.Json; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace Nest +{ + public class LMDirichletSimilarity : SimilarityBase + { + public LMDirichletSimilarity() + { + this.Type = "LMDirichlet"; + } + + [JsonProperty("mu")] + public int Mu { get; set; } + } +} diff --git a/src/Nest/Domain/Similarity/LMJelinekSimilarity.cs b/src/Nest/Domain/Similarity/LMJelinekSimilarity.cs new file mode 100644 index 00000000000..a602953eb0b --- /dev/null +++ b/src/Nest/Domain/Similarity/LMJelinekSimilarity.cs @@ -0,0 +1,19 @@ +using Newtonsoft.Json; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace Nest +{ + public class LMJelinekSimilarity : SimilarityBase + { + public LMJelinekSimilarity() + { + this.Type = "LMJelinekMercer"; + } + + [JsonProperty("lambda")] + public double Lambda { get; set; } + } +} diff --git a/src/Nest/Domain/Similarity/SimilarityBase.cs b/src/Nest/Domain/Similarity/SimilarityBase.cs new file mode 100644 index 00000000000..a83cb2c69c6 --- /dev/null +++ b/src/Nest/Domain/Similarity/SimilarityBase.cs @@ -0,0 +1,29 @@ +using Newtonsoft.Json; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace Nest +{ + public class SimilarityBase + { + [JsonProperty("type")] + public string Type { get; protected set; } + + [JsonProperty("normalization")] + public string Normalization { get; set; } + + [JsonProperty("normalization.h1.c")] + public string NormalizationH1C { get; set; } + + [JsonProperty("normalization.h2.c")] + public string NormalizationH2C { get; set; } + + [JsonProperty("normalization.h3.c")] + public string NormalizationH3C { get; set; } + + [JsonProperty("normalization.z.z")] + public string NormalizationZZ { get; set; } + } +} diff --git a/src/Nest/Domain/Similarity/SimilaritySettings.cs b/src/Nest/Domain/Similarity/SimilaritySettings.cs new file mode 100644 index 00000000000..dd9c015b770 --- /dev/null +++ b/src/Nest/Domain/Similarity/SimilaritySettings.cs @@ -0,0 +1,22 @@ + +using Nest.Resolvers.Converters; +using Newtonsoft.Json; +using System; +using System.Collections.Generic; + +namespace Nest +{ + [JsonConverter(typeof(SimilaritySettingsConverter))] + public class SimilaritySettings + { + public SimilaritySettings() + { + this.CustomSimilarities = new Dictionary(); + } + + public string Default { get; set; } + + [JsonConverter(typeof(SimilarityCollectionConverter))] + public IDictionary CustomSimilarities { get; set; } + } +} diff --git a/src/Nest/Nest.csproj b/src/Nest/Nest.csproj index 90c962e9fd8..2a7d7cec9fd 100644 --- a/src/Nest/Nest.csproj +++ b/src/Nest/Nest.csproj @@ -152,6 +152,13 @@ + + + + + + + @@ -168,6 +175,7 @@ + @@ -405,7 +413,6 @@ Code - @@ -422,7 +429,7 @@ - + @@ -637,6 +644,7 @@ + @@ -745,6 +753,7 @@ + diff --git a/src/Nest/Resolvers/Converters/IndexSettingsConverter.cs b/src/Nest/Resolvers/Converters/IndexSettingsConverter.cs index 651cf3875cd..a6e5705bcf2 100644 --- a/src/Nest/Resolvers/Converters/IndexSettingsConverter.cs +++ b/src/Nest/Resolvers/Converters/IndexSettingsConverter.cs @@ -2,7 +2,6 @@ using System.Collections.Generic; using System.Linq; using Elasticsearch.Net; -using Nest.Domain.Settings; using Newtonsoft.Json; using Newtonsoft.Json.Linq; @@ -48,11 +47,7 @@ private void WriteSettings(JsonWriter writer, JsonSerializer serializer, IndexSe writer.WritePropertyName("settings"); writer.WriteStartObject(); WriteIndexSettings(writer, serializer, indexSettings); - - WriteSimilarityModuleSettings(writer, indexSettings); - writer.WriteEndObject(); - } private static void WriteAliases(JsonWriter writer, JsonSerializer serializer, IndexSettings indexSettings) @@ -88,43 +83,6 @@ private static void WriteMappings(JsonWriter writer, JsonSerializer serializer, ); } - private static void WriteSimilarityModuleSettings(JsonWriter writer, IndexSettings indexSettings) - { - if (indexSettings.Similarity == null) return; - writer.WritePropertyName("similarity"); - writer.WriteStartObject(); - - if (!string.IsNullOrEmpty(indexSettings.Similarity.BaseSimilarity)) - { - writer.WritePropertyName("base"); - writer.WriteStartObject(); - writer.WritePropertyName("type"); - writer.WriteValue(indexSettings.Similarity.BaseSimilarity); - writer.WriteEndObject(); - } - - if (indexSettings.Similarity.CustomSimilarities != null) - { - foreach (var customSimilarity in indexSettings.Similarity.CustomSimilarities) - { - writer.WritePropertyName(customSimilarity.Name); - writer.WriteStartObject(); - writer.WritePropertyName("type"); - writer.WriteValue(customSimilarity.Type); - if (customSimilarity.SimilarityParameters.HasAny()) - { - foreach (var kv in customSimilarity.SimilarityParameters) - { - writer.WritePropertyName(kv.Key); - writer.WriteValue(kv.Value); - } - } - writer.WriteEndObject(); - } - } - writer.WriteEndObject(); - } - private void WriteIndexSettings(JsonWriter writer, JsonSerializer serializer, IndexSettings indexSettings) { writer.WritePropertyName("index"); @@ -152,6 +110,15 @@ private void WriteIndexSettings(JsonWriter writer, JsonSerializer serializer, In serializer.Serialize(writer, indexSettings.Analysis); } + if ( + indexSettings.Similarity.CustomSimilarities.Count > 0 + || !string.IsNullOrEmpty(indexSettings.Similarity.Default) + ) + { + writer.WritePropertyName("similarity"); + serializer.Serialize(writer, indexSettings.Similarity); + } + writer.WriteEndObject(); } @@ -181,30 +148,7 @@ public override object ReadJson(JsonReader reader, Type objectType, object exist } else if (rootProperty.Name.Equals("similarity", StringComparison.InvariantCultureIgnoreCase)) { - var baseSimilarity = ((JObject)rootProperty.Value).Property("base"); - if (baseSimilarity != null) - { - baseSimilarity.Remove(); - result.Similarity = new SimilaritySettings(((JObject)baseSimilarity.Value).Property("type").Value.ToString()); - } - else - { - result.Similarity = new SimilaritySettings(); - } - - foreach (var similarityProperty in rootProperty.Value.Children()) - { - var typeProperty = ((JObject)similarityProperty.Value).Property("type"); - typeProperty.Remove(); - var customSimilarity = new CustomSimilaritySettings(similarityProperty.Name, typeProperty.Value.ToString()); - foreach (var similaritySetting in similarityProperty.Value.Children()) - { - customSimilarity.SimilarityParameters.Add(similaritySetting.Name, similaritySetting.Value.ToString()); - } - - result.Similarity.CustomSimilarities.RemoveAll(x => x.Name == customSimilarity.Name); - result.Similarity.CustomSimilarities.Add(customSimilarity); - } + result.Similarity = serializer.Deserialize(rootProperty.Value.CreateReader()); result.Settings.Remove(rootProperty.Name); } } diff --git a/src/Nest/Resolvers/Converters/SimilarityCollectionConverter.cs b/src/Nest/Resolvers/Converters/SimilarityCollectionConverter.cs new file mode 100644 index 00000000000..8ba2dd91d04 --- /dev/null +++ b/src/Nest/Resolvers/Converters/SimilarityCollectionConverter.cs @@ -0,0 +1,60 @@ +using Newtonsoft.Json; +using Newtonsoft.Json.Linq; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace Nest.Resolvers.Converters +{ + public class SimilarityCollectionConverter : JsonConverter + { + public override bool CanConvert(Type objectType) + { + return typeof(IDictionary).IsAssignableFrom(objectType); + } + + public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) + { + JObject o = JObject.Load(reader); + var result = existingValue as Dictionary ?? new Dictionary(); + + foreach (var childProperty in o.Children()) + { + var propertyName = childProperty.Name; + var typeProperty = ((JObject)childProperty.Value).Property("type"); + typeProperty.Remove(); + + var typePropertyValue = typeProperty.Value.ToString(); + var itemType = Type.GetType("Nest." + typePropertyValue + "Similarity", false, true); + + SimilarityBase item; + + if (itemType != null) + { + item = serializer.Deserialize(childProperty.Value.CreateReader(), itemType) as SimilarityBase; + } + else + { + continue; + } + + result[propertyName] = item; + } + + return result; + } + + public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) + { + var items = (IDictionary)value; + writer.WriteStartObject(); + foreach(var item in items) + { + writer.WritePropertyName(item.Key); + serializer.Serialize(writer, item.Value); + } + writer.WriteEndObject(); + } + } +} diff --git a/src/Nest/Resolvers/Converters/SimilaritySettingsConverter.cs b/src/Nest/Resolvers/Converters/SimilaritySettingsConverter.cs new file mode 100644 index 00000000000..00a8d3505c4 --- /dev/null +++ b/src/Nest/Resolvers/Converters/SimilaritySettingsConverter.cs @@ -0,0 +1,49 @@ +using Newtonsoft.Json; +using Newtonsoft.Json.Linq; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace Nest.Resolvers.Converters +{ + public class SimilaritySettingsConverter : JsonConverter + { + public override bool CanConvert(Type objectType) + { + return objectType == typeof(SimilaritySettings); + } + + public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) + { + JObject o = JObject.Load(reader); + var result = existingValue as SimilaritySettings ?? new SimilaritySettings(); + + foreach(var rootProperty in o.Children()) + { + var typeProperty = ((JObject)rootProperty.Value).Property("type"); + var itemType = Type.GetType("Nest." + typeProperty.Value.ToString() + "Similarity", false, true); + var similarity = serializer.Deserialize(rootProperty.Value.CreateReader(), itemType) as SimilarityBase; + result.CustomSimilarities.Add(rootProperty.Name, similarity); + } + + return result; + } + + public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) + { + var similarityValue = (SimilaritySettings)value; + + if(similarityValue.CustomSimilarities.Count > 0) + { + serializer.Serialize(writer, similarityValue.CustomSimilarities); + } + + if (!string.IsNullOrEmpty(similarityValue.Default)) + { + writer.WritePropertyName("similarity.default.type"); + writer.WriteValue(similarityValue.Default); + } + } + } +} diff --git a/src/Tests/Nest.Tests.Integration/Indices/IndicesTests.cs b/src/Tests/Nest.Tests.Integration/Indices/IndicesTests.cs index 1a0f81e9744..4ff9754c82b 100644 --- a/src/Tests/Nest.Tests.Integration/Indices/IndicesTests.cs +++ b/src/Tests/Nest.Tests.Integration/Indices/IndicesTests.cs @@ -2,7 +2,6 @@ using System.Collections.Generic; using System.Linq; using FluentAssertions; -using Nest.Domain.Settings; using Nest.Resolvers; using Nest.Tests.MockData; using Nest.Tests.MockData.Domain; @@ -42,6 +41,7 @@ public void GetIndexSettingsSimple() [Test] public void GetIndexSettingsComplex() + { var index = Guid.NewGuid().ToString(); var settings = new IndexSettings(); @@ -61,19 +61,19 @@ public void GetIndexSettingsComplex() settings.Analysis.Tokenizers.Add("token1", new KeywordTokenizer()); settings.Analysis.Tokenizers.Add("token2", new PathHierarchyTokenizer()); - settings.Similarity = new SimilaritySettings(); - var dfr = new CustomSimilaritySettings("test1", "DFR"); - dfr.SimilarityParameters.Add("basic_model", "g"); - dfr.SimilarityParameters.Add("after_effect", "l"); - dfr.SimilarityParameters.Add("normalization", "h2"); - dfr.SimilarityParameters.Add("normalization.h2.c", 3); - settings.Similarity.CustomSimilarities.Add(dfr); + settings.Similarity.CustomSimilarities.Add("test1", new DFRSimilarity + { + BasicModel = "be", + AfterEffect = "l", + Normalization = "h2", + }); - var ib = new CustomSimilaritySettings("test2", "IB"); - ib.SimilarityParameters.Add("distribution", "spl"); - ib.SimilarityParameters.Add("lambda", "ttf"); - ib.SimilarityParameters.Add("normalization", "h1"); - settings.Similarity.CustomSimilarities.Add(ib); + settings.Similarity.CustomSimilarities.Add("test2", new IBSimilarity + { + Distribution = "spl", + Lambda = "ttf", + Normalization = "h1" + }); var typeMappingResult = this._client.GetMapping(gm=>gm.Index(ElasticsearchConfiguration.DefaultIndex).Type("elasticsearchprojects")); var typeMapping = typeMappingResult.Mapping; @@ -163,22 +163,19 @@ public void GetIndexSettingsComplex() Assert.NotNull(r.IndexSettings.Similarity.CustomSimilarities); Assert.AreEqual(2, r.IndexSettings.Similarity.CustomSimilarities.Count); { // assert similarity - var similarity1 = r.IndexSettings.Similarity.CustomSimilarities.FirstOrDefault(x => x.Name.Equals("test1", StringComparison.InvariantCultureIgnoreCase)); + var similarity1 = r.IndexSettings.Similarity.CustomSimilarities.FirstOrDefault(x => x.Key.Equals("test1", StringComparison.InvariantCultureIgnoreCase)).Value as DFRSimilarity; Assert.NotNull(similarity1); Assert.AreEqual("DFR", similarity1.Type); - Assert.AreEqual(4, similarity1.SimilarityParameters.Count); - Assert.True(similarity1.SimilarityParameters.Any(x => x.Key.Equals("basic_model") && x.Value.ToString().Equals("g"))); - Assert.True(similarity1.SimilarityParameters.Any(x => x.Key.Equals("after_effect") && x.Value.ToString().Equals("l"))); - Assert.True(similarity1.SimilarityParameters.Any(x => x.Key.Equals("normalization") && x.Value.ToString().Equals("h2"))); - Assert.True(similarity1.SimilarityParameters.Any(x => x.Key.Equals("normalization.h2"))); + Assert.AreEqual("be", similarity1.BasicModel); + Assert.AreEqual("l", similarity1.AfterEffect); + Assert.AreEqual("h2", similarity1.Normalization); - var similarity2 = r.IndexSettings.Similarity.CustomSimilarities.FirstOrDefault(x => x.Name.Equals("test2", StringComparison.InvariantCultureIgnoreCase)); + var similarity2 = r.IndexSettings.Similarity.CustomSimilarities.FirstOrDefault(x => x.Key.Equals("test2", StringComparison.InvariantCultureIgnoreCase)).Value as IBSimilarity; Assert.NotNull(similarity2); Assert.AreEqual("IB", similarity2.Type); - Assert.AreEqual(3, similarity2.SimilarityParameters.Count); - Assert.True(similarity2.SimilarityParameters.Any(x => x.Key.Equals("distribution") && x.Value.ToString().Equals("spl"))); - Assert.True(similarity2.SimilarityParameters.Any(x => x.Key.Equals("lambda") && x.Value.ToString().Equals("ttf"))); - Assert.True(similarity2.SimilarityParameters.Any(x => x.Key.Equals("normalization") && x.Value.ToString().Equals("h1"))); + Assert.AreEqual("spl", similarity2.Distribution); + Assert.AreEqual("ttf", similarity2.Lambda); + Assert.AreEqual("h1", similarity2.Normalization); } this._client.DeleteIndex(i=>i.Index(index)); } diff --git a/src/Tests/Nest.Tests.Integration/Reproduce/Reproduce308Tests.cs b/src/Tests/Nest.Tests.Integration/Reproduce/Reproduce308Tests.cs index 418afc1c08e..6866e33c94e 100644 --- a/src/Tests/Nest.Tests.Integration/Reproduce/Reproduce308Tests.cs +++ b/src/Tests/Nest.Tests.Integration/Reproduce/Reproduce308Tests.cs @@ -23,7 +23,6 @@ public class Reproduce308Tests : IntegrationTests public void ShouldBeAbleToSetIndexToReadonly() { var settings = new IndexSettings(); - settings.Similarity = new SimilaritySettings(); settings.NumberOfReplicas = 1; settings.NumberOfShards = 5; settings.Settings.Add("index.blocks.read_only", "true"); diff --git a/src/Tests/Nest.Tests.Integration/Reproduce/Reproduce319Tests.cs b/src/Tests/Nest.Tests.Integration/Reproduce/Reproduce319Tests.cs index 5cad15a974d..c3984e3166c 100644 --- a/src/Tests/Nest.Tests.Integration/Reproduce/Reproduce319Tests.cs +++ b/src/Tests/Nest.Tests.Integration/Reproduce/Reproduce319Tests.cs @@ -24,7 +24,6 @@ public class Reproduce319Tests : IntegrationTests public void CreateIndexShouldNotThrowNullReference() { var settings = new IndexSettings(); - settings.Similarity = new SimilaritySettings(); settings.NumberOfReplicas = 1; settings.NumberOfShards = 5; settings.Settings.Add("index.refresh_interval", "10s"); diff --git a/src/Tests/Nest.Tests.Unit/Core/Indices/Similarity/BM25SimilarityTest.json b/src/Tests/Nest.Tests.Unit/Core/Indices/Similarity/BM25SimilarityTest.json new file mode 100644 index 00000000000..fb50ef276aa --- /dev/null +++ b/src/Tests/Nest.Tests.Unit/Core/Indices/Similarity/BM25SimilarityTest.json @@ -0,0 +1,16 @@ +{ + "settings": { + "index": { + "similarity": { + "my_bm25_similarity": { + "k1": 2.0, + "b" : 0.75, + "discount_overlaps": true, + "type": "BM25", + "normalization": "h1", + "normalization.h1.c": "1.0" + } + } + } + } +} diff --git a/src/Tests/Nest.Tests.Unit/Core/Indices/Similarity/DFRSimilarityTest.json b/src/Tests/Nest.Tests.Unit/Core/Indices/Similarity/DFRSimilarityTest.json new file mode 100644 index 00000000000..d740f5259a2 --- /dev/null +++ b/src/Tests/Nest.Tests.Unit/Core/Indices/Similarity/DFRSimilarityTest.json @@ -0,0 +1,15 @@ +{ + "settings": { + "index": { + "similarity": { + "my_dfr_similarity": { + "basic_model": "g", + "after_effect": "l", + "type": "DFR", + "normalization": "h3", + "normalization.h2.c": "3.0" + } + } + } + } +} diff --git a/src/Tests/Nest.Tests.Unit/Core/Indices/Similarity/DefaultSimilarityTest.json b/src/Tests/Nest.Tests.Unit/Core/Indices/Similarity/DefaultSimilarityTest.json new file mode 100644 index 00000000000..28b9baffc92 --- /dev/null +++ b/src/Tests/Nest.Tests.Unit/Core/Indices/Similarity/DefaultSimilarityTest.json @@ -0,0 +1,14 @@ +{ + "settings": { + "index": { + "similarity": { + "my_default_similarity": { + "discount_overlaps": true, + "type": "default", + "normalization": "h2", + "normalization.h2.c": "2.0" + } + } + } + } +} diff --git a/src/Tests/Nest.Tests.Unit/Core/Indices/Similarity/IBSimilarityTest.json b/src/Tests/Nest.Tests.Unit/Core/Indices/Similarity/IBSimilarityTest.json new file mode 100644 index 00000000000..4c2c2e66755 --- /dev/null +++ b/src/Tests/Nest.Tests.Unit/Core/Indices/Similarity/IBSimilarityTest.json @@ -0,0 +1,15 @@ +{ + "settings": { + "index": { + "similarity": { + "my_ib_similarity": { + "distribution": "spl", + "lambda": "df", + "type": "IB", + "normalization": "h2", + "normalization.h2.c": "3.0" + } + } + } + } +} diff --git a/src/Tests/Nest.Tests.Unit/Core/Indices/Similarity/LMDirichletSimilarityTest.json b/src/Tests/Nest.Tests.Unit/Core/Indices/Similarity/LMDirichletSimilarityTest.json new file mode 100644 index 00000000000..87ba22fe59e --- /dev/null +++ b/src/Tests/Nest.Tests.Unit/Core/Indices/Similarity/LMDirichletSimilarityTest.json @@ -0,0 +1,12 @@ +{ + "settings": { + "index": { + "similarity": { + "my_lmdirichlet_similarity": { + "mu": 1000, + "type": "LMDirichlet" + } + } + } + } +} diff --git a/src/Tests/Nest.Tests.Unit/Core/Indices/Similarity/LMJelinekSimilarityTest.json b/src/Tests/Nest.Tests.Unit/Core/Indices/Similarity/LMJelinekSimilarityTest.json new file mode 100644 index 00000000000..04d6c247598 --- /dev/null +++ b/src/Tests/Nest.Tests.Unit/Core/Indices/Similarity/LMJelinekSimilarityTest.json @@ -0,0 +1,12 @@ +{ + "settings": { + "index": { + "similarity": { + "my_lmjelinek_similarity": { + "lambda": 0.5, + "type": "LMJelinekMercer" + } + } + } + } +} diff --git a/src/Tests/Nest.Tests.Unit/Core/Indices/Similarity/MultipleSimilaritiesTest.json b/src/Tests/Nest.Tests.Unit/Core/Indices/Similarity/MultipleSimilaritiesTest.json new file mode 100644 index 00000000000..761ad584639 --- /dev/null +++ b/src/Tests/Nest.Tests.Unit/Core/Indices/Similarity/MultipleSimilaritiesTest.json @@ -0,0 +1,22 @@ +{ + "settings": { + "index": { + "similarity": { + "my_dfr_similarity": { + "basic_model": "g", + "after_effect": "l", + "type": "DFR", + "normalization": "h3", + "normalization.h2.c": "3.0" + }, + "my_ib_similarity": { + "distribution": "spl", + "lambda": "df", + "type": "IB", + "normalization": "h2", + "normalization.h2.c": "3.0" + } + } + } + } +} diff --git a/src/Tests/Nest.Tests.Unit/Core/Indices/Similarity/SimilarityTests.cs b/src/Tests/Nest.Tests.Unit/Core/Indices/Similarity/SimilarityTests.cs new file mode 100644 index 00000000000..74fb66a979b --- /dev/null +++ b/src/Tests/Nest.Tests.Unit/Core/Indices/Similarity/SimilarityTests.cs @@ -0,0 +1,143 @@ +using FluentAssertions; +using NUnit.Framework; +using System; +using System.Reflection; + +namespace Nest.Tests.Unit.Core.Indices.Similarity +{ + [TestFixture] + public class SimilarityTests : BaseJsonTests + { + [Test] + public void BM25SimilarityTest() + { + var result = this.Similarity(s => s + .CustomSimilarities(cs => cs.Add("my_bm25_similarity", new BM25Similarity + { + K1 = 2.0, + B = 0.75, + Normalization = "h1", + NormalizationH1C = "1.0", + DiscountOverlaps = true + }) + ) + ); + + this.JsonEquals(result.ConnectionStatus.Request, MethodInfo.GetCurrentMethod()); + } + + [Test] + public void DefaultSimilarityTest() + { + var result = this.Similarity(s => s + .CustomSimilarities(cs => cs.Add("my_default_similarity", new DefaultSimilarity + { + DiscountOverlaps = true, + Normalization = "h2", + NormalizationH2C = "2.0" + }) + ) + ); + + this.JsonEquals(result.ConnectionStatus.Request, MethodInfo.GetCurrentMethod()); + } + + [Test] + public void DFRSimilarityTest() + { + var result = this.Similarity(s => s + .CustomSimilarities(cs => cs.Add("my_dfr_similarity", new DFRSimilarity + { + BasicModel = "g", + AfterEffect = "l", + Normalization = "h3", + NormalizationH2C = "3.0" + }) + ) + ); + + this.JsonEquals(result.ConnectionStatus.Request, MethodInfo.GetCurrentMethod()); + } + + [Test] + public void IBSimilarityTest() + { + var result = this.Similarity(s => s + .CustomSimilarities(cs => cs.Add("my_ib_similarity", new IBSimilarity + { + Distribution = "spl", + Lambda = "df", + Normalization = "h2", + NormalizationH2C = "3.0" + }) + ) + ); + + this.JsonEquals(result.ConnectionStatus.Request, MethodInfo.GetCurrentMethod()); + } + + [Test] + public void LMDirichletSimilarityTest() + { + var result = this.Similarity(s => s + .CustomSimilarities(cs => cs.Add("my_lmdirichlet_similarity", new LMDirichletSimilarity + { + Mu = 1000 + }) + ) + ); + + this.JsonEquals(result.ConnectionStatus.Request, MethodInfo.GetCurrentMethod()); + } + + [Test] + public void LMJelinekSimilarityTest() + { + var result = this.Similarity(s => s + .CustomSimilarities(cs => cs.Add("my_lmjelinek_similarity", new LMJelinekSimilarity + { + Lambda = 0.5 + }) + ) + ); + + this.JsonEquals(result.ConnectionStatus.Request, MethodInfo.GetCurrentMethod()); + } + + [Test] + public void MultipleSimilaritiesTest() + { + var result = this.Similarity(s => s + .CustomSimilarities(cs => cs + .Add("my_dfr_similarity", new DFRSimilarity + { + BasicModel = "g", + AfterEffect = "l", + Normalization = "h3", + NormalizationH2C = "3.0" + }) + .Add("my_ib_similarity", new IBSimilarity + { + Distribution = "spl", + Lambda = "df", + Normalization = "h2", + NormalizationH2C = "3.0" + }) + ) + ); + + this.JsonEquals(result.ConnectionStatus.Request, MethodInfo.GetCurrentMethod()); + } + + private IIndicesOperationResponse Similarity(Func similaritySelector) + { + var result = this._client.CreateIndex(UnitTestDefaults.DefaultIndex, c => c + .Similarity(similaritySelector) + ); + result.Should().NotBeNull(); + result.IsValid.Should().BeTrue(); + result.ConnectionStatus.Should().NotBeNull(); + return result; + } + } +}