public void FacetQuery() { var mocks = new MockRepository(); var query = new Dictionary <string, string>(); query["q"] = ""; query["rows"] = SolrQueryExecuter <TestDocumentWithUniqueKey> .ConstDefaultRows.ToString(); query["facet"] = "true"; query["facet.query"] = "id:1"; var connection = new MockConnection(query); var parser = mocks.StrictMock <ISolrQueryResultParser <TestDocumentWithUniqueKey> >(); var docSerializer = mocks.StrictMock <ISolrDocumentSerializer <TestDocumentWithUniqueKey> >(); var querySerializer = new DefaultQuerySerializer(new DefaultFieldSerializer()); var facetQuerySerializer = new DefaultFacetQuerySerializer(querySerializer, new DefaultFieldSerializer()); With.Mocks(mocks).Expecting(() => { Expect.On(parser) .Call(parser.Parse(null)) .IgnoreArguments() .Return(new SolrQueryResults <TestDocumentWithUniqueKey>()); }).Verify(() => { var executer = new SolrQueryExecuter <TestDocumentWithUniqueKey>(parser, connection, querySerializer, facetQuerySerializer); var solr = new SolrBasicServer <TestDocumentWithUniqueKey>(connection, executer, docSerializer, null, null, null, null, null); var r = solr.Query(new SolrQuery(""), new QueryOptions { Facet = new FacetParameters { Queries = new ISolrFacetQuery[] { new SolrFacetQuery(new SolrQuery("id:1")), }, } }); }); }
public void GetTermVectorParameterOptions_offsets() { var r = SolrQueryExecuter <TestDocument> .GetTermVectorParameterOptions(TermVectorParameterOptions.Offsets).ToList(); Assert.Single(r); Assert.Equal("tv.offsets", r[0]); }
public void ExecuteMLT_with_stream_body_query() { var parser = new MSolrMoreLikeThisHandlerQueryResultsParser <SolrQueryExecuterTests.TestDocument>(); var q = new Dictionary <string, string>(); q["mlt"] = "true"; q["mlt.fl"] = "one,three"; q["mlt.match.include"] = "false"; q["mlt.match.offset"] = "5"; q["mlt.interestingTerms"] = InterestingTerms.None.ToString().ToLowerInvariant(); q["start"] = "0"; q["rows"] = "5"; q["fl"] = "one,two,three"; var conn = new MockConnection(q, MediaTypeNames.Text.Plain, "one two three"); var qe = new SolrQueryExecuter <SolrQueryExecuterTests.TestDocument>(null, conn, null, null, parser); var r = qe.ExecuteAsync(new SolrMoreLikeThisHandlerStreamBodyQuery("one two three"), new MoreLikeThisHandlerQueryOptions( new MoreLikeThisHandlerParameters(new[] { "one", "three" }) { MatchInclude = false, MatchOffset = 5, ShowTerms = InterestingTerms.None, }) { Start = 0, Rows = 5, Fields = new[] { "one", "two", "three" }, }); }
public void GetTermVectorParameterOptions_Df() { var r = SolrQueryExecuter <TestDocument> .GetTermVectorParameterOptions(TermVectorParameterOptions.DocumentFrequency).ToList(); Assert.Single(r); Assert.Equal("tv.df", r[0]); }
public void GetTermVectorParameterOptions_All() { var r = SolrQueryExecuter <TestDocument> .GetTermVectorParameterOptions(TermVectorParameterOptions.All).ToList(); Assert.Single(r); Assert.Equal("tv.all", r[0]); }
public void Facets() { var q = new Dictionary <string, string>(); q["q"] = ""; q["rows"] = SolrQueryExecuter <TestDocument> .ConstDefaultRows.ToString(); q["facet"] = "true"; q["facet.field"] = "Id"; q["facet.query"] = "id:[1 TO 5]"; var conn = new MockConnection(q); var mocks = new MockRepository(); var parser = mocks.DynamicMock <ISolrQueryResultParser <TestDocument> >(); var querySerializer = new DefaultQuerySerializer(new DefaultFieldSerializer()); var facetQuerySerializer = new DefaultFacetQuerySerializer(querySerializer, new DefaultFieldSerializer()); var queryExecuter = new SolrQueryExecuter <TestDocument>(parser, conn, querySerializer, facetQuerySerializer); queryExecuter.Execute(new SolrQuery(""), new QueryOptions { Facet = new FacetParameters { Queries = new ISolrFacetQuery[] { new SolrFacetFieldQuery("Id"), new SolrFacetQuery(new SolrQuery("id:[1 TO 5]")), } } }); }
public void NullableDateTime() { var mocks = new MockRepository(); var connection = mocks.StrictMock <ISolrConnection>(); var responseParser = mocks.DynamicMock <ISolrHeaderResponseParser>(); var resultParser = mocks.StrictMock <ISolrQueryResultParser <TestDocWithNullable> >(); var queryExecuter = new SolrQueryExecuter <TestDocWithNullable>(resultParser, connection, null, null); var mapper = new AttributesMappingManager(); var docSerializer = new SolrDocumentSerializer <TestDocWithNullable>(mapper, new DefaultFieldSerializer()); var validationManager = mocks.StrictMock <IMappingValidator>(); var basicSolr = new SolrBasicServer <TestDocWithNullable>(connection, queryExecuter, docSerializer, null, responseParser, null, null, null); var solr = new SolrServer <TestDocWithNullable>(basicSolr, mapper, validationManager); string xml = null; With.Mocks(mocks) .Expecting(() => { Expect.On(connection) .Call(connection.Post(null, null)) .IgnoreArguments() .Do(new Writer(delegate(string u, string s) { Console.WriteLine(s); xml = s; return(EmbeddedResource.GetEmbeddedString(GetType(), "Resources.response.xml")); })); }) .Verify(() => { solr.Add(new TestDocWithNullable()); Assert.AreEqual("<add><doc /></add>", xml); }); }
public void QueryWithPagination() { const string qstring = "id:123"; const int start = 10; const int rows = 20; var connection = new MSolrConnection(); connection.get += (url, param) => { Assert.AreEqual("/select", url); var expectedParams = new Dictionary <string, string> { { "q", qstring }, { "start", start.ToString() }, { "rows", rows.ToString() }, }; CollectionAssert.AreEquivalent(expectedParams, param); return(EmbeddedResource.GetEmbeddedString(GetType(), "Resources.response.xml")); }; var querySerializer = new MSolrQuerySerializer(); querySerializer.serialize += _ => qstring; var resultParser = new MSolrAbstractResponseParser <TestDocumentWithUniqueKey>(); resultParser.parse &= x => x.Stub(); var executer = new SolrQueryExecuter <TestDocumentWithUniqueKey>(resultParser, connection, querySerializer, null, null); var solr = new SolrBasicServer <TestDocumentWithUniqueKey>(connection, executer, null, null, null, null, null, null); var r = solr.Query(new SolrQuery(qstring), new QueryOptions { Start = start, Rows = rows }); Assert.AreEqual(1, connection.get.Calls); }
public void Execute() { const string queryString = "id:123456"; var q = new Dictionary<string, string>(); q["q"] = queryString; var conn = new MockConnection(q); var mocks = new MockRepository(); var parser = mocks.StrictMock<ISolrQueryResultParser<TestDocument>>(); var mockR = mocks.DynamicMock<SolrQueryResults<TestDocument>>(); var serializer = mocks.StrictMock<ISolrQuerySerializer>(); With.Mocks(mocks).Expecting(() => { Expect.On(parser) .Call(parser.Parse(null)) .IgnoreArguments() .Repeat.Once() .Return(mockR); Expect.On(serializer) .Call(serializer.Serialize(null)) .IgnoreArguments() .Repeat.Once() .Return(queryString); }).Verify(() => { var queryExecuter = new SolrQueryExecuter<TestDocument>(parser, conn, serializer, null, null); var r = queryExecuter.Execute(new SolrQuery(queryString), null); }); }
public void MultipleFacetFields() { var conn = new MockConnection(new[] { KV.Create("q", ""), KV.Create("rows", SolrQueryExecuter <TestDocument> .ConstDefaultRows.ToString()), KV.Create("facet", "true"), KV.Create("facet.field", "Id"), KV.Create("facet.field", "OtherField"), }); var serializer = new DefaultQuerySerializer(new DefaultFieldSerializer()); var facetQuerySerializer = new DefaultFacetQuerySerializer(serializer, new DefaultFieldSerializer()); var parser = new MSolrAbstractResponseParser <TestDocument>(); parser.parse &= x => x.Stub(); var queryExecuter = new SolrQueryExecuter <TestDocument>(parser, conn, serializer, facetQuerySerializer, null); queryExecuter.Execute(new SolrQuery(""), new QueryOptions { Facet = new FacetParameters { Queries = new ISolrFacetQuery[] { new SolrFacetFieldQuery("Id"), new SolrFacetFieldQuery("OtherField"), } } }); }
public void FilterQuery() { var querySerializer = new DefaultQuerySerializer(new DefaultFieldSerializer()); var conn = new MockConnection(new[] { KV.Create("q", "*:*"), KV.Create("rows", "10"), KV.Create("fq", "id:0"), KV.Create("fq", "id:2"), }); var parser = new MSolrAbstractResponseParser <TestDocument>(); parser.parse &= x => x.Stub(); var queryExecuter = new SolrQueryExecuter <TestDocument>(parser, conn, querySerializer, null, null) { DefaultRows = 10, }; queryExecuter.Execute(SolrQuery.All, new QueryOptions { FilterQueries = new[] { new SolrQuery("id:0"), new SolrQuery("id:2"), }, }); }
public void FacetFieldOptions() { var querySerializer = new SolrQuerySerializerStub("q"); var facetQuerySerializer = new DefaultFacetQuerySerializer(querySerializer, null); var queryExecuter = new SolrQueryExecuter<TestDocument>(null, null, querySerializer, facetQuerySerializer, null); var facetOptions = queryExecuter.GetFacetFieldOptions( new FacetParameters { Queries = new List<ISolrFacetQuery> { new SolrFacetQuery(new SolrQuery("q")), }, Prefix = "pref", EnumCacheMinDf = 123, Limit = 100, MinCount = 5, Missing = true, Offset = 55, Sort = true, }).ToDictionary(x => x.Key, x => x.Value); Assert.AreEqual("pref", facetOptions["facet.prefix"]); Assert.AreEqual("123", facetOptions["facet.enum.cache.minDf"]); Assert.AreEqual("100", facetOptions["facet.limit"]); Assert.AreEqual("5", facetOptions["facet.mincount"]); Assert.AreEqual("true", facetOptions["facet.missing"]); Assert.AreEqual("55", facetOptions["facet.offset"]); Assert.AreEqual("true", facetOptions["facet.sort"]); }
public void Execute() { const string queryString = "id:123456"; var q = new Dictionary <string, string>(); q["q"] = queryString; var conn = new MockConnection(q); var mocks = new MockRepository(); var parser = mocks.StrictMock <ISolrQueryResultParser <TestDocument> >(); var mockR = mocks.DynamicMock <SolrQueryResults <TestDocument> >(); var serializer = mocks.StrictMock <ISolrQuerySerializer>(); With.Mocks(mocks).Expecting(() => { Expect.On(parser) .Call(parser.Parse(null)) .IgnoreArguments() .Repeat.Once() .Return(mockR); Expect.On(serializer) .Call(serializer.Serialize(null)) .IgnoreArguments() .Repeat.Once() .Return(queryString); }).Verify(() => { var queryExecuter = new SolrQueryExecuter <TestDocument>(parser, conn, serializer, null, null); var r = queryExecuter.Execute(new SolrQuery(queryString), null); }); }
public void TermsSingleField() { var p = SolrQueryExecuter <TestDocument> .GetTermsParameters(new QueryOptions { Terms = new TermsParameters("text") { Limit = 10, Lower = "lower", LowerInclude = true, MaxCount = 10, MinCount = 0, Prefix = "pre", Raw = true, Regex = "regex", RegexFlag = new[] { RegexFlag.CanonEq, RegexFlag.CaseInsensitive }, Sort = TermsSort.Count, Upper = "upper", UpperInclude = true }, }).ToList(); Assert.Contains(p, KV.Create("terms", "true")); Assert.Contains(p, KV.Create("terms.fl", "text")); Assert.Contains(p, KV.Create("terms.lower", "lower")); Assert.Contains(p, KV.Create("terms.lower.incl", "true")); Assert.Contains(p, KV.Create("terms.maxcount", "10")); Assert.Contains(p, KV.Create("terms.mincount", "0")); Assert.Contains(p, KV.Create("terms.prefix", "pre")); Assert.Contains(p, KV.Create("terms.raw", "true")); Assert.Contains(p, KV.Create("terms.regex", "regex")); Assert.Contains(p, KV.Create("terms.regex.flag", RegexFlag.CanonEq.ToString())); Assert.Contains(p, KV.Create("terms.regex.flag", RegexFlag.CaseInsensitive.ToString())); Assert.Contains(p, KV.Create("terms.sort", "count")); Assert.Contains(p, KV.Create("terms.upper", "upper")); Assert.Contains(p, KV.Create("terms.upper.incl", "true")); }
public void ExtraParams() { var mocks = new MockRepository(); var parser = mocks.DynamicMock <ISolrQueryResultParser <TestDocument> >(); var conn = mocks.DynamicMock <ISolrConnection>(); var serializer = mocks.StrictMock <ISolrQuerySerializer>(); With.Mocks(mocks) .Expecting(() => Expect.On(serializer) .Call(serializer.Serialize(null)) .IgnoreArguments() .Return("123123")) .Verify(() => { var queryExecuter = new SolrQueryExecuter <TestDocument>(parser, conn, serializer, null, null); var p = queryExecuter.GetAllParameters(new SolrQuery("123123"), new QueryOptions { ExtraParams = new Dictionary <string, string> { { "qt", "geo" }, { "lat", "40.75141843299745" }, { "long", "-74.0093994140625" }, { "radius", "1" }, } }).ToDictionary(x => x.Key, x => x.Value); Assert.AreEqual("123123", p["q"]); Assert.AreEqual("geo", p["qt"]); Assert.AreEqual("1", p["radius"]); }); }
public void GetClusteringParameters() { var mocks = new MockRepository(); var parser = mocks.DynamicMock <ISolrQueryResultParser <TestDocument> >(); var conn = mocks.DynamicMock <ISolrConnection>(); var querySerializer = new SolrQuerySerializerStub("apache"); var queryExecuter = new SolrQueryExecuter <TestDocument>(parser, conn, querySerializer, null, null); var p = queryExecuter.GetAllParameters(new SolrQuery("apache"), new QueryOptions { Clustering = new ClusteringParameters { Title = "headline", FragSize = 10, LexicalResources = "fakedir", ProduceSummary = true, Algorithm = "org.carrot2.clustering.lingo.LingoClusteringAlgorithm", Url = "none", Collection = false, Engine = "default", SubClusters = false, Snippet = "synopsis", NumDescriptions = 20 }, }).ToList(); Assert.Contains(p, KV.Create("carrot.title", "headline")); Assert.Contains(p, KV.Create("clustering.engine", "default")); Assert.Contains(p, KV.Create("clustering.collection", "false")); Assert.Contains(p, KV.Create("carrot.algorithm", "org.carrot2.clustering.lingo.LingoClusteringAlgorithm")); Assert.Contains(p, KV.Create("carrot.url", "none")); Assert.Contains(p, KV.Create("carrot.snippet", "synopsis")); Assert.Contains(p, KV.Create("carrot.produceSummary", "true")); Assert.Contains(p, KV.Create("carrot.fragSize", "10")); Assert.Contains(p, KV.Create("carrot.numDescriptions", "20")); Assert.Contains(p, KV.Create("carrot.outputSubClusters", "false")); Assert.Contains(p, KV.Create("carrot.lexicalResourcesDir", "fakedir")); }
public void HighlightingWithoutFieldsOutputsPrePost() { const string afterTerm = "after"; const string beforeTerm = "before"; var q = new Dictionary <string, string>(); q["q"] = ""; q["rows"] = SolrQueryExecuter <TestDocument> .ConstDefaultRows.ToString(); q["hl"] = "true"; q["hl.tag.pre"] = beforeTerm; q["hl.tag.post"] = afterTerm; q["hl.useFastVectorHighlighter"] = "true"; var conn = new MockConnection(q); var querySerializer = new SolrQuerySerializerStub(""); var parser = new MSolrAbstractResponseParser <TestDocument>(); parser.parse &= x => x.Stub(); var queryExecuter = new SolrQueryExecuter <TestDocument>(parser, conn, querySerializer, null, null); queryExecuter.Execute(new SolrQuery(""), new QueryOptions { Highlight = new HighlightingParameters { AfterTerm = afterTerm, BeforeTerm = beforeTerm, UseFastVectorHighlighter = true, } }); }
public void FacetFieldOptions() { var mocks = new MockRepository(); var parser = mocks.DynamicMock <ISolrQueryResultParser <TestDocument> >(); var conn = mocks.DynamicMock <ISolrConnection>(); var querySerializer = new SolrQuerySerializerStub("q"); var facetQuerySerializer = new DefaultFacetQuerySerializer(querySerializer, null); var queryExecuter = new SolrQueryExecuter <TestDocument>(parser, conn, querySerializer, facetQuerySerializer, null); var facetOptions = queryExecuter.GetFacetFieldOptions( new FacetParameters { Queries = new List <ISolrFacetQuery> { new SolrFacetQuery(new SolrQuery("q")), }, Prefix = "pref", EnumCacheMinDf = 123, Limit = 100, MinCount = 5, Missing = true, Offset = 55, Sort = true, }).ToDictionary(x => x.Key, x => x.Value); Assert.AreEqual("pref", facetOptions["facet.prefix"]); Assert.AreEqual("123", facetOptions["facet.enum.cache.minDf"]); Assert.AreEqual("100", facetOptions["facet.limit"]); Assert.AreEqual("5", facetOptions["facet.mincount"]); Assert.AreEqual("true", facetOptions["facet.missing"]); Assert.AreEqual("55", facetOptions["facet.offset"]); Assert.AreEqual("true", facetOptions["facet.sort"]); }
public void GetTermVectorParameterOptions_Tf() { var r = SolrQueryExecuter <object> .GetTermVectorParameterOptions(TermVectorParameterOptions.TermFrequency).ToList(); Assert.AreEqual(1, r.Count); Assert.AreEqual("tv.tf", r[0]); }
public void GetMoreLikeThisParameters() { var mocks = new MockRepository(); var parser = mocks.DynamicMock <ISolrQueryResultParser <TestDocument> >(); var conn = mocks.DynamicMock <ISolrConnection>(); var queryExecuter = new SolrQueryExecuter <TestDocument>(parser, conn, null, null, null); var p = queryExecuter.GetMoreLikeThisParameters( new MoreLikeThisParameters(new[] { "field1", "field2" }) { Boost = true, Count = 10, QueryFields = new[] { "qf1", "qf2" }, MaxQueryTerms = 2, MaxTokens = 3, MaxWordLength = 4, MinDocFreq = 5, MinTermFreq = 6, MinWordLength = 7, }).ToList(); Assert.Contains(p, KV.Create("mlt", "true")); Assert.Contains(p, KV.Create("mlt.boost", "true")); Assert.Contains(p, KV.Create("mlt.count", "10")); Assert.Contains(p, KV.Create("mlt.maxqt", "2")); Assert.Contains(p, KV.Create("mlt.maxntp", "3")); Assert.Contains(p, KV.Create("mlt.maxwl", "4")); Assert.Contains(p, KV.Create("mlt.mindf", "5")); Assert.Contains(p, KV.Create("mlt.mintf", "6")); Assert.Contains(p, KV.Create("mlt.minwl", "7")); Assert.Contains(p, KV.Create("mlt.fl", "field1,field2")); Assert.Contains(p, KV.Create("mlt.qf", "qf1,qf2")); }
public void Highlighting() { var mocks = new MockRepository(); var parser = mocks.DynamicMock <ISolrQueryResultParser <TestDocument> >(); const string highlightedField = "field1"; const string afterTerm = "after"; const string beforeTerm = "before"; const int snippets = 3; const string alt = "alt"; const int fragsize = 7; var q = new Dictionary <string, string>(); q["q"] = ""; q["rows"] = SolrQueryExecuter <TestDocument> .ConstDefaultRows.ToString(); q["hl"] = "true"; q["hl.fl"] = highlightedField; q["hl.snippets"] = snippets.ToString(); q["hl.fragsize"] = fragsize.ToString(); q["hl.requireFieldMatch"] = "true"; q["hl.alternateField"] = alt; q["hl.tag.pre"] = beforeTerm; q["hl.tag.post"] = afterTerm; q["hl.regex.slop"] = "4.12"; q["hl.regex.pattern"] = "\\."; q["hl.regex.maxAnalyzedChars"] = "8000"; q["hl.usePhraseHighlighter"] = "true"; q["hl.useFastVectorHighlighter"] = "true"; q["hl.highlightMultiTerm"] = "true"; q["hl.mergeContiguous"] = "true"; q["hl.maxAnalyzedChars"] = "12"; q["hl.maxAlternateFieldLength"] = "22"; q["hl.fragmenter"] = "regex"; var conn = new MockConnection(q); var querySerializer = new SolrQuerySerializerStub(""); var queryExecuter = new SolrQueryExecuter <TestDocument>(parser, conn, querySerializer, null, null); queryExecuter.Execute(new SolrQuery(""), new QueryOptions { Highlight = new HighlightingParameters { Fields = new[] { highlightedField }, AfterTerm = afterTerm, BeforeTerm = beforeTerm, Snippets = snippets, AlternateField = alt, Fragsize = fragsize, RequireFieldMatch = true, RegexSlop = 4.12, RegexPattern = "\\.", RegexMaxAnalyzedChars = 8000, UsePhraseHighlighter = true, UseFastVectorHighlighter = true, MergeContiguous = true, MaxAnalyzedChars = 12, HighlightMultiTerm = true, MaxAlternateFieldLength = 22, Fragmenter = SolrHighlightFragmenter.Regex } }); }
public void FacetQuery() { var connection = new MSolrConnection(); connection.get += (url, param) => { Assert.AreEqual("/select", url); var expectedParams = new Dictionary <string, string> { { "q", "" }, { "rows", SolrQueryExecuter <TestDocumentWithUniqueKey> .ConstDefaultRows.ToString() }, { "facet", "true" }, { "facet.query", "id:1" }, }; CollectionAssert.AreEquivalent(expectedParams, param); return(EmbeddedResource.GetEmbeddedString(GetType(), "Resources.response.xml")); }; var querySerializer = new DefaultQuerySerializer(new DefaultFieldSerializer()); var facetQuerySerializer = new DefaultFacetQuerySerializer(querySerializer, new DefaultFieldSerializer()); var parser = new MSolrAbstractResponseParser <TestDocumentWithUniqueKey>(); parser.parse &= x => x.Stub(); var executer = new SolrQueryExecuter <TestDocumentWithUniqueKey>(parser, connection, querySerializer, facetQuerySerializer, null); var solr = new SolrBasicServer <TestDocumentWithUniqueKey>(connection, executer, null, null, null, null, null, null); var r = solr.Query(new SolrQuery(""), new QueryOptions { Facet = new FacetParameters { Queries = new ISolrFacetQuery[] { new SolrFacetQuery(new SolrQuery("id:1")), }, } }); Assert.AreEqual(1, connection.get.Calls); }
public void GetMoreLikeThisParameters() { var queryExecuter = new SolrQueryExecuter <TestDocument>(null, null, null, null, null); var p = queryExecuter.GetMoreLikeThisParameters( new MoreLikeThisParameters(new[] { "field1", "field2" }) { Boost = true, Count = 10, QueryFields = new[] { "qf1", "qf2" }, MaxQueryTerms = 2, MaxTokens = 3, MaxWordLength = 4, MinDocFreq = 5, MinTermFreq = 6, MinWordLength = 7, }).ToList(); Assert.Contains(KV.Create("mlt", "true"), p); Assert.Contains(KV.Create("mlt.boost", "true"), p); Assert.Contains(KV.Create("mlt.count", "10"), p); Assert.Contains(KV.Create("mlt.maxqt", "2"), p); Assert.Contains(KV.Create("mlt.maxntp", "3"), p); Assert.Contains(KV.Create("mlt.maxwl", "4"), p); Assert.Contains(KV.Create("mlt.mindf", "5"), p); Assert.Contains(KV.Create("mlt.mintf", "6"), p); Assert.Contains(KV.Create("mlt.minwl", "7"), p); Assert.Contains(KV.Create("mlt.fl", "field1,field2"), p); Assert.Contains(KV.Create("mlt.qf", "qf1,qf2"), p); }
public void FacetFieldOptions() { var querySerializer = new SolrQuerySerializerStub("q"); var facetQuerySerializer = new DefaultFacetQuerySerializer(querySerializer, null); var queryExecuter = new SolrQueryExecuter <TestDocument>(null, null, querySerializer, facetQuerySerializer, null); var facetOptions = queryExecuter.GetFacetFieldOptions( new FacetParameters { Queries = new List <ISolrFacetQuery> { new SolrFacetQuery(new SolrQuery("q")), }, Prefix = "pref", EnumCacheMinDf = 123, Limit = 100, MinCount = 5, Missing = true, Offset = 55, Sort = true, Threads = 5 }).ToDictionary(x => x.Key, x => x.Value); Assert.Equal("pref", facetOptions["facet.prefix"]); Assert.Equal("123", facetOptions["facet.enum.cache.minDf"]); Assert.Equal("100", facetOptions["facet.limit"]); Assert.Equal("5", facetOptions["facet.mincount"]); Assert.Equal("true", facetOptions["facet.missing"]); Assert.Equal("55", facetOptions["facet.offset"]); Assert.Equal("true", facetOptions["facet.sort"]); Assert.Equal("5", facetOptions["facet.threads"]); }
public void GetAllParameters_with_spelling() { var querySerializer = new SolrQuerySerializerStub("*:*"); var queryExecuter = new SolrQueryExecuter <TestDocument>(null, null, querySerializer, null, null); var p = queryExecuter.GetAllParameters(SolrQuery.All, new QueryOptions { SpellCheck = new SpellCheckingParameters { Query = "hell", Build = true, Collate = true, Count = 4, Dictionary = "spanish", OnlyMorePopular = true, Reload = true, }, }).ToList(); Assert.Contains(KV.Create("spellcheck", "true"), p); Assert.Contains(KV.Create("spellcheck.q", "hell"), p); Assert.Contains(KV.Create("spellcheck.build", "true"), p); Assert.Contains(KV.Create("spellcheck.collate", "true"), p); Assert.Contains(KV.Create("spellcheck.count", "4"), p); Assert.Contains(KV.Create("spellcheck.dictionary", "spanish"), p); Assert.Contains(KV.Create("spellcheck.onlyMorePopular", "true"), p); Assert.Contains(KV.Create("spellcheck.reload", "true"), p); }
public void GetTermVectorParameterOptions_offsets() { var r = SolrQueryExecuter <object> .GetTermVectorParameterOptions(TermVectorParameterOptions.Offsets).ToList(); Assert.Equal(1, r.Count); Assert.Equal("tv.offsets", r[0]); }
public void GetTermVectorParameterOptions_Df() { var r = SolrQueryExecuter <object> .GetTermVectorParameterOptions(TermVectorParameterOptions.DocumentFrequency).ToList(); Assert.Equal(1, r.Count); Assert.Equal("tv.df", r[0]); }
public void Sort() { const string queryString = "id:123456"; var q = new Dictionary <string, string>(); q["q"] = queryString; q["rows"] = SolrQueryExecuter <TestDocument> .ConstDefaultRows.ToString(); q["sort"] = "id asc"; var conn = new MockConnection(q); var mocks = new MockRepository(); var parser = mocks.StrictMock <ISolrQueryResultParser <TestDocument> >(); var mockR = mocks.DynamicMock <SolrQueryResults <TestDocument> >(); var querySerializer = new SolrQuerySerializerStub(queryString); With.Mocks(mocks).Expecting(() => { Expect.Call(parser.Parse(null)) .IgnoreArguments() .Repeat.Once() .Return(mockR); }).Verify(() => { var queryExecuter = new SolrQueryExecuter <TestDocument>(parser, conn, querySerializer, null, null); var r = queryExecuter.Execute(new SolrQuery(queryString), new QueryOptions { OrderBy = new[] { new SortOrder("id") } }); }); }
public void GetAllParameters_with_spelling() { var mocks = new MockRepository(); var parser = mocks.DynamicMock <ISolrQueryResultParser <TestDocument> >(); var conn = mocks.DynamicMock <ISolrConnection>(); var querySerializer = new SolrQuerySerializerStub("*:*"); var queryExecuter = new SolrQueryExecuter <TestDocument>(parser, conn, querySerializer, null, null); var p = queryExecuter.GetAllParameters(SolrQuery.All, new QueryOptions { SpellCheck = new SpellCheckingParameters { Query = "hell", Build = true, Collate = true, Count = 4, Dictionary = "spanish", OnlyMorePopular = true, Reload = true, }, }).ToList(); Assert.Contains(p, KV.Create("spellcheck", "true")); Assert.Contains(p, KV.Create("spellcheck.q", "hell")); Assert.Contains(p, KV.Create("spellcheck.build", "true")); Assert.Contains(p, KV.Create("spellcheck.collate", "true")); Assert.Contains(p, KV.Create("spellcheck.count", "4")); Assert.Contains(p, KV.Create("spellcheck.dictionary", "spanish")); Assert.Contains(p, KV.Create("spellcheck.onlyMorePopular", "true")); Assert.Contains(p, KV.Create("spellcheck.reload", "true")); }
public void ExtraParams() { var mocks = new MockRepository(); var parser = mocks.DynamicMock<ISolrQueryResultParser<TestDocument>>(); var conn = mocks.DynamicMock<ISolrConnection>(); var serializer = mocks.StrictMock<ISolrQuerySerializer>(); With.Mocks(mocks) .Expecting(() => Expect.On(serializer) .Call(serializer.Serialize(null)) .IgnoreArguments() .Return("123123")) .Verify(() => { var queryExecuter = new SolrQueryExecuter<TestDocument>(parser, conn, serializer, null, null); var p = queryExecuter.GetAllParameters(new SolrQuery("123123"), new QueryOptions { ExtraParams = new Dictionary<string, string> { {"qt", "geo"}, {"lat", "40.75141843299745"}, {"long", "-74.0093994140625"}, {"radius", "1"}, } }).ToDictionary(x => x.Key, x => x.Value); Assert.AreEqual("123123", p["q"]); Assert.AreEqual("geo", p["qt"]); Assert.AreEqual("1", p["radius"]); }); }
public void GetTermVectorParameterOptions_All() { var r = SolrQueryExecuter <object> .GetTermVectorParameterOptions(TermVectorParameterOptions.All).ToList(); Assert.AreEqual(1, r.Count); Assert.AreEqual("tv.all", r[0]); }
public void Facets() { var q = new Dictionary <string, string>(); q["q"] = ""; q["rows"] = SolrQueryExecuter <TestDocument> .ConstDefaultRows.ToString(); q["facet"] = "true"; q["facet.field"] = "Id"; q["facet.query"] = "id:[1 TO 5]"; var conn = new MockConnection(q); var querySerializer = new DefaultQuerySerializer(new DefaultFieldSerializer()); var parser = new MSolrAbstractResponseParser <TestDocument>(); parser.parse &= x => x.Stub(); var facetQuerySerializer = new DefaultFacetQuerySerializer(querySerializer, new DefaultFieldSerializer()); var queryExecuter = new SolrQueryExecuter <TestDocument>(parser, conn, querySerializer, facetQuerySerializer, null); queryExecuter.Execute(new SolrQuery(""), new QueryOptions { Facet = new FacetParameters { Queries = new ISolrFacetQuery[] { new SolrFacetFieldQuery("Id"), new SolrFacetQuery(new SolrQuery("id:[1 TO 5]")), } } }); }
public void GetAllParameters_mlt_with_field_query() { var mocks = new MockRepository(); var parser = mocks.DynamicMock <ISolrQueryResultParser <TestDocument> >(); var conn = mocks.DynamicMock <ISolrConnection>(); var serializer = new DefaultQuerySerializer(new DefaultFieldSerializer()); var qe = new SolrQueryExecuter <TestDocument>(parser, conn, serializer, null, null); var p = qe.GetAllMoreLikeThisHandlerParameters( new SolrMoreLikeThisHandlerQuery(new SolrQueryByField("id", "1234")), new MoreLikeThisHandlerQueryOptions( new MoreLikeThisHandlerParameters(new[] { "one", "three" }) { MatchInclude = false, MatchOffset = 5, ShowTerms = InterestingTerms.None, }) { Start = 0, Rows = 5, Fields = new[] { "one", "two", "three" }, }).ToList(); Assert.Contains(p, KV.Create("q", "(id:1234)")); Assert.Contains(p, KV.Create("start", "0")); Assert.Contains(p, KV.Create("rows", "5")); Assert.Contains(p, KV.Create("fl", "one,two,three")); Assert.Contains(p, KV.Create("mlt.fl", "one,three")); Assert.Contains(p, KV.Create("mlt.match.include", "false")); Assert.Contains(p, KV.Create("mlt.match.offset", "5")); Assert.Contains(p, KV.Create("mlt.interestingTerms", "none")); }
public void Execute() { const string queryString = "id:123456"; var q = new Dictionary<string, string>(); q["q"] = queryString; var conn = new MockConnection(q); var serializer = new MSolrQuerySerializer(); serializer.serialize += _ => queryString; var parser = new MSolrAbstractResponseParser<TestDocument>(); parser.parse &= x => x.Stub(); var queryExecuter = new SolrQueryExecuter<TestDocument>(parser, conn, serializer, null, null); var r = queryExecuter.Execute(new SolrQuery(queryString), null); Assert.AreEqual(1, serializer.serialize.Calls); }
public void ExtraParams() { var querySerializer = new SolrQuerySerializerStub("123123"); var queryExecuter = new SolrQueryExecuter<TestDocument>(null, null, querySerializer, null, null); var p = queryExecuter.GetAllParameters(new SolrQuery("123123"), new QueryOptions { ExtraParams = new Dictionary<string, string> { {"qt", "geo"}, {"lat", "40.75141843299745"}, {"long", "-74.0093994140625"}, {"radius", "1"}, } }).ToDictionary(x => x.Key, x => x.Value); Assert.AreEqual("123123", p["q"]); Assert.AreEqual("geo", p["qt"]); Assert.AreEqual("1", p["radius"]); }
public void Sort() { const string queryString = "id:123456"; var q = new Dictionary<string, string>(); q["q"] = queryString; q["rows"] = SolrQueryExecuter<TestDocument>.ConstDefaultRows.ToString(); q["sort"] = "id asc"; var conn = new MockConnection(q); var querySerializer = new SolrQuerySerializerStub(queryString); var parser = new MSolrAbstractResponseParser<TestDocument>(); parser.parse &= x => x.Expect(1); var queryExecuter = new SolrQueryExecuter<TestDocument>(parser, conn, querySerializer, null, null); var r = queryExecuter.Execute(new SolrQuery(queryString), new QueryOptions { OrderBy = new[] { new SortOrder("id") } }); parser.parse.Verify(); }
public void tt() { var mocks = new MockRepository(); var connection = mocks.StrictMock<ISolrConnection>(); var parser = mocks.StrictMock<ISolrQueryResultParser<TestDocument>>(); With.Mocks(mocks).Expecting(delegate { Expect.Call(connection.Get(null, null)) .IgnoreArguments() .Repeat.Once() .Return(""); Expect.Call(parser.Parse(null)) .IgnoreArguments() .Repeat.Once() .Return(new SolrQueryResults<TestDocument>()); }).Verify(delegate { var q = new SolrQueryExecuter<TestDocument>(parser, connection, null, null); var r = q.Execute(new SolrQuery("id:123456"), null); }); }
public void ResultFields() { const string queryString = "id:123456"; var q = new Dictionary<string, string>(); q["q"] = queryString; q["rows"] = SolrQueryExecuter<TestDocument>.ConstDefaultRows.ToString(); q["fl"] = "id,name"; var conn = new MockConnection(q); var querySerializer = new SolrQuerySerializerStub(queryString); var parser = new MSolrAbstractResponseParser<TestDocument>(); parser.parse &= x => x.Stub(); var queryExecuter = new SolrQueryExecuter<TestDocument>(parser, conn, querySerializer, null, null); var r = queryExecuter.Execute(new SolrQuery(queryString), new QueryOptions { Fields = new[] { "id", "name" }, }); }
public void SpellChecking() { var queryExecuter = new SolrQueryExecuter<TestDocument>(null, null, null, null, null); var p = queryExecuter.GetSpellCheckingParameters(new QueryOptions { SpellCheck = new SpellCheckingParameters { Query = "hell", Build = true, Collate = true, Count = 4, Dictionary = "spanish", OnlyMorePopular = true, Reload = true, }, }).ToList(); Assert.Contains(p, KV.Create("spellcheck", "true")); Assert.Contains(p, KV.Create("spellcheck.q", "hell")); Assert.Contains(p, KV.Create("spellcheck.build", "true")); Assert.Contains(p, KV.Create("spellcheck.collate", "true")); Assert.Contains(p, KV.Create("spellcheck.count", "4")); Assert.Contains(p, KV.Create("spellcheck.dictionary", "spanish")); Assert.Contains(p, KV.Create("spellcheck.onlyMorePopular", "true")); Assert.Contains(p, KV.Create("spellcheck.reload", "true")); }
public void MoreLikeThis() { var querySerializer = new SolrQuerySerializerStub("apache"); var queryExecuter = new SolrQueryExecuter<TestDocument>(null, null, querySerializer, null, null); var p = queryExecuter.GetAllParameters(new SolrQuery("apache"), new QueryOptions { MoreLikeThis = new MoreLikeThisParameters(new[] { "manu", "cat" }) { MinDocFreq = 1, MinTermFreq = 1, }, }).ToList(); Assert.Contains(p, KV.Create("mlt", "true")); Assert.Contains(p, KV.Create("mlt.mindf", "1")); Assert.Contains(p, KV.Create("mlt.fl", "manu,cat")); Assert.Contains(p, KV.Create("mlt.mintf", "1")); Assert.Contains(p, KV.Create("q", "apache")); }
public void MultipleFacetFields() { var conn = new MockConnection(new[] { KV.Create("q", ""), KV.Create("rows", SolrQueryExecuter<TestDocument>.ConstDefaultRows.ToString()), KV.Create("facet", "true"), KV.Create("facet.field", "Id"), KV.Create("facet.field", "OtherField"), }); var serializer = new DefaultQuerySerializer(new DefaultFieldSerializer()); var facetQuerySerializer = new DefaultFacetQuerySerializer(serializer, new DefaultFieldSerializer()); var parser = new MSolrAbstractResponseParser<TestDocument>(); parser.parse &= x => x.Stub(); var queryExecuter = new SolrQueryExecuter<TestDocument>(parser, conn, serializer, facetQuerySerializer, null); queryExecuter.Execute(new SolrQuery(""), new QueryOptions { Facet = new FacetParameters { Queries = new ISolrFacetQuery[] { new SolrFacetFieldQuery("Id"), new SolrFacetFieldQuery("OtherField"), } } }); }
public void NullableDateTime() { var mocks = new MockRepository(); var connection = mocks.CreateMock<ISolrConnection>(); var resultParser = mocks.CreateMock<ISolrQueryResultParser<TestDocWithNullable>>(); var queryExecuter = new SolrQueryExecuter<TestDocWithNullable>(connection, resultParser); var mapper = new AttributesMappingManager(); var docSerializer = new SolrDocumentSerializer<TestDocWithNullable>(mapper, new DefaultFieldSerializer()); var basicSolr = new SolrBasicServer<TestDocWithNullable>(connection, queryExecuter, docSerializer); var solr = new SolrServer<TestDocWithNullable>(basicSolr, mapper); string xml = null; With.Mocks(mocks) .Expecting(() => { Expect.Call(connection.Post(null, null)) .IgnoreArguments() .Do(new Writer(delegate(string u, string s) { Console.WriteLine(s); xml = s; return null; })); }) .Verify(() => { solr.Add(new TestDocWithNullable()); Assert.AreEqual("<add><doc /></add>", xml); }); }
public void HighlightingWithFastVectorHighlighter() { var e = new SolrQueryExecuter<TestDocument>(null, null, null, null, null); var p = e.GetHighlightingParameters(new QueryOptions { Highlight = new HighlightingParameters { Fields = new[] {"a"}, AfterTerm = "after", BeforeTerm = "before", UseFastVectorHighlighter = true, } }); Assert.AreEqual("true", p["hl.useFastVectorHighlighter"]); Assert.AreEqual("before", p["hl.tag.pre"]); Assert.AreEqual("after", p["hl.tag.post"]); Assert.IsFalse(p.ContainsKey("hl.simple.pre")); Assert.IsFalse(p.ContainsKey("hl.simple.post")); }
public void GetClusteringParameters() { var querySerializer = new SolrQuerySerializerStub("apache"); var queryExecuter = new SolrQueryExecuter<TestDocument>(null, null, querySerializer, null, null); var p = queryExecuter.GetAllParameters(new SolrQuery("apache"), new QueryOptions { Clustering = new ClusteringParameters { Title = "headline", FragSize = 10, LexicalResources = "fakedir", ProduceSummary = true, Algorithm = "org.carrot2.clustering.lingo.LingoClusteringAlgorithm", Url = "none", Collection = false, Engine = "default", SubClusters = false, Snippet = "synopsis", NumDescriptions = 20 }, }).ToList(); Assert.Contains(p, KV.Create("carrot.title", "headline")); Assert.Contains(p, KV.Create("clustering.engine", "default")); Assert.Contains(p, KV.Create("clustering.collection", "false")); Assert.Contains(p, KV.Create("carrot.algorithm", "org.carrot2.clustering.lingo.LingoClusteringAlgorithm")); Assert.Contains(p, KV.Create("carrot.url", "none")); Assert.Contains(p, KV.Create("carrot.snippet", "synopsis")); Assert.Contains(p, KV.Create("carrot.produceSummary", "true")); Assert.Contains(p, KV.Create("carrot.fragSize", "10")); Assert.Contains(p, KV.Create("carrot.numDescriptions", "20")); Assert.Contains(p, KV.Create("carrot.outputSubClusters", "false")); Assert.Contains(p, KV.Create("carrot.lexicalResourcesDir", "fakedir")); }
public void GetCursormarkWithDefaultSetup() { var e = new SolrQueryExecuter<TestDocument>(null, null, null, null, null); var p = e.GetCommonParameters(new QueryOptions { StartOrCursor = StartOrCursor.Cursor.Start }); Assert.AreEqual("cursorMark", p.First().Key); Assert.AreEqual("*", p.First().Value); }
public void GetAllParameters_mlt_with_field_query() { var serializer = new DefaultQuerySerializer(new DefaultFieldSerializer()); var qe = new SolrQueryExecuter<TestDocument>(null, null, serializer, null, null); var p = qe.GetAllMoreLikeThisHandlerParameters( new SolrMoreLikeThisHandlerQuery(new SolrQueryByField("id", "1234")), new MoreLikeThisHandlerQueryOptions( new MoreLikeThisHandlerParameters(new[] { "one", "three" }) { MatchInclude = false, MatchOffset = 5, ShowTerms = InterestingTerms.None, }) { Start = 0, Rows = 5, Fields = new[] { "one", "two", "three" }, }).ToList(); Assert.Contains(p, KV.Create("q", "id:(1234)")); Assert.Contains(p, KV.Create("start", "0")); Assert.Contains(p, KV.Create("rows", "5")); Assert.Contains(p, KV.Create("fl", "one,two,three")); Assert.Contains(p, KV.Create("mlt.fl", "one,three")); Assert.Contains(p, KV.Create("mlt.match.include", "false")); Assert.Contains(p, KV.Create("mlt.match.offset", "5")); Assert.Contains(p, KV.Create("mlt.interestingTerms", "none")); }
public void GetAllParameters_mlt_with_stream_url_query() { var qe = new SolrQueryExecuter<TestDocument>(null, null, null, null, null); var p = qe.GetAllMoreLikeThisHandlerParameters( new SolrMoreLikeThisHandlerStreamUrlQuery("http://wiki.apache.org/solr/MoreLikeThisHandler"), new MoreLikeThisHandlerQueryOptions( new MoreLikeThisHandlerParameters(new[] { "one", "three" }) { MatchInclude = false, MatchOffset = 5, ShowTerms = InterestingTerms.None, }) { Start = 0, Rows = 5, Fields = new[] { "one", "two", "three" }, }).ToList(); Assert.Contains(p, KV.Create("stream.url", "http://wiki.apache.org/solr/MoreLikeThisHandler")); }
public void FilterQuery() { var querySerializer = new DefaultQuerySerializer(new DefaultFieldSerializer()); var conn = new MockConnection(new[] { KV.Create("q", "*:*"), KV.Create("rows", "10"), KV.Create("fq", "id:0"), KV.Create("fq", "id:2"), }); var parser = new MSolrAbstractResponseParser<TestDocument>(); parser.parse &= x => x.Stub(); var queryExecuter = new SolrQueryExecuter<TestDocument>(parser, conn, querySerializer, null, null) { DefaultRows = 10, }; queryExecuter.Execute(SolrQuery.All, new QueryOptions { FilterQueries = new[] { new SolrQuery("id:0"), new SolrQuery("id:2"), }, }); }
public void Facets() { var q = new Dictionary<string, string>(); q["q"] = ""; q["rows"] = SolrQueryExecuter<TestDocument>.ConstDefaultRows.ToString(); q["facet"] = "true"; q["facet.field"] = "Id"; q["facet.query"] = "id:[1 TO 5]"; var conn = new MockConnection(q); var querySerializer = new DefaultQuerySerializer(new DefaultFieldSerializer()); var parser = new MSolrAbstractResponseParser<TestDocument>(); parser.parse &= x => x.Stub(); var facetQuerySerializer = new DefaultFacetQuerySerializer(querySerializer, new DefaultFieldSerializer()); var queryExecuter = new SolrQueryExecuter<TestDocument>(parser, conn, querySerializer, facetQuerySerializer, null); queryExecuter.Execute(new SolrQuery(""), new QueryOptions { Facet = new FacetParameters { Queries = new ISolrFacetQuery[] { new SolrFacetFieldQuery("Id"), new SolrFacetQuery(new SolrQuery("id:[1 TO 5]")), } } }); }
public void QueryWithPagination() { const string qstring = "id:123"; const int start = 10; const int rows = 20; var mocks = new MockRepository(); //var connection = mocks.CreateMock<ISolrConnection>(); var query = new Dictionary<string, string>(); query["q"] = qstring; query["start"] = start.ToString(); query["rows"] = rows.ToString(); var connection = new MockConnection(query); var parser = mocks.CreateMock<ISolrQueryResultParser<TestDocumentWithUniqueKey>>(); var docSerializer = mocks.CreateMock<ISolrDocumentSerializer<TestDocumentWithUniqueKey>>(); With.Mocks(mocks).Expecting(() => { Expect.On(parser).Call(parser.Parse(null)) .IgnoreArguments() .Return(new SolrQueryResults<TestDocumentWithUniqueKey>()); }).Verify(() => { var executer = new SolrQueryExecuter<TestDocumentWithUniqueKey>(connection, parser); var solr = new SolrBasicServer<TestDocumentWithUniqueKey>(connection, executer, docSerializer); var r = solr.Query(new SolrQuery(qstring), new QueryOptions {Start = start, Rows = rows}); }); }
public void GetCursormarkWithMarkSet() { var e = new SolrQueryExecuter<TestDocument>(null, null, null, null, null); var p = e.GetCommonParameters(new QueryOptions { StartOrCursor = new StartOrCursor.Cursor("AoEoZTQ3YmY0NDM=") }); Assert.AreEqual("cursorMark", p.First().Key); Assert.AreEqual("AoEoZTQ3YmY0NDM=", p.First().Value); }
public void GetMoreLikeThisParameters() { var queryExecuter = new SolrQueryExecuter<TestDocument>(null, null, null, null, null); var p = queryExecuter.GetMoreLikeThisParameters( new MoreLikeThisParameters(new[] { "field1", "field2" }) { Boost = true, Count = 10, QueryFields = new[] { "qf1", "qf2" }, MaxQueryTerms = 2, MaxTokens = 3, MaxWordLength = 4, MinDocFreq = 5, MinTermFreq = 6, MinWordLength = 7, }).ToList(); Assert.Contains(p, KV.Create("mlt", "true")); Assert.Contains(p, KV.Create("mlt.boost", "true")); Assert.Contains(p, KV.Create("mlt.count", "10")); Assert.Contains(p, KV.Create("mlt.maxqt", "2")); Assert.Contains(p, KV.Create("mlt.maxntp", "3")); Assert.Contains(p, KV.Create("mlt.maxwl", "4")); Assert.Contains(p, KV.Create("mlt.mindf", "5")); Assert.Contains(p, KV.Create("mlt.mintf", "6")); Assert.Contains(p, KV.Create("mlt.minwl", "7")); Assert.Contains(p, KV.Create("mlt.fl", "field1,field2")); Assert.Contains(p, KV.Create("mlt.qf", "qf1,qf2")); }
public void StatsOptions() { var queryExecuter = new SolrQueryExecuter<TestDocument>(null, null, null, null, null); var statsOptions = queryExecuter.GetStatsQueryOptions(new QueryOptions { Stats = new StatsParameters() .AddField("popularity") .AddFieldWithFacet("price", "inStock") .AddFieldWithFacets("afield", "facet1", "facet2") .AddFacet("globalfacet") }).ToList(); Assert.AreEqual(8, statsOptions.Count); Assert.Contains(statsOptions, KV.Create("stats", "true")); Assert.Contains(statsOptions, KV.Create("stats.field", "popularity")); Assert.Contains(statsOptions, KV.Create("stats.field", "price")); Assert.Contains(statsOptions, KV.Create("f.price.stats.facet", "inStock")); Assert.Contains(statsOptions, KV.Create("stats.field", "afield")); Assert.Contains(statsOptions, KV.Create("f.afield.stats.facet", "facet1")); Assert.Contains(statsOptions, KV.Create("f.afield.stats.facet", "facet2")); Assert.Contains(statsOptions, KV.Create("stats.facet", "globalfacet")); }
public void Highlighting() { const string highlightedField = "field1"; const string afterTerm = "after"; const string beforeTerm = "before"; const int snippets = 3; const string alt = "alt"; const int fragsize = 7; var q = new Dictionary<string, string>(); q["q"] = ""; q["rows"] = SolrQueryExecuter<TestDocument>.ConstDefaultRows.ToString(); q["hl"] = "true"; q["hl.fl"] = highlightedField; q["hl.snippets"] = snippets.ToString(); q["hl.fragsize"] = fragsize.ToString(); q["hl.requireFieldMatch"] = "true"; q["hl.alternateField"] = alt; q["hl.tag.pre"] = beforeTerm; q["hl.tag.post"] = afterTerm; q["hl.regex.slop"] = "4.12"; q["hl.regex.pattern"] = "\\."; q["hl.regex.maxAnalyzedChars"] = "8000"; q["hl.usePhraseHighlighter"] = "true"; q["hl.useFastVectorHighlighter"] = "true"; q["hl.highlightMultiTerm"] = "true"; q["hl.mergeContiguous"] = "true"; q["hl.maxAnalyzedChars"] = "12"; q["hl.maxAlternateFieldLength"] = "22"; q["hl.fragmenter"] = "regex"; var conn = new MockConnection(q); var querySerializer = new SolrQuerySerializerStub(""); var parser = new MSolrAbstractResponseParser<TestDocument>(); parser.parse &= x => x.Stub(); var queryExecuter = new SolrQueryExecuter<TestDocument>(parser, conn, querySerializer, null, null); queryExecuter.Execute(new SolrQuery(""), new QueryOptions { Highlight = new HighlightingParameters { Fields = new[] { highlightedField }, AfterTerm = afterTerm, BeforeTerm = beforeTerm, Snippets = snippets, AlternateField = alt, Fragsize = fragsize, RequireFieldMatch = true, RegexSlop = 4.12, RegexPattern = "\\.", RegexMaxAnalyzedChars = 8000, UsePhraseHighlighter = true, UseFastVectorHighlighter = true, MergeContiguous = true, MaxAnalyzedChars = 12, HighlightMultiTerm = true, MaxAlternateFieldLength = 22, Fragmenter = SolrHighlightFragmenter.Regex } }); }
public void NullableDateTime() { var mocks = new MockRepository(); var connection = mocks.StrictMock<ISolrConnection>(); var responseParser = mocks.DynamicMock<ISolrHeaderResponseParser>(); var resultParser = mocks.StrictMock<ISolrQueryResultParser<TestDocWithNullable>>(); var queryExecuter = new SolrQueryExecuter<TestDocWithNullable>(resultParser, connection, null, null); var mapper = new AttributesMappingManager(); var docSerializer = new SolrDocumentSerializer<TestDocWithNullable>(mapper, new DefaultFieldSerializer()); var validationManager = mocks.StrictMock<IMappingValidator>(); var basicSolr = new SolrBasicServer<TestDocWithNullable>(connection, queryExecuter, docSerializer, null, responseParser, null, null, null); var solr = new SolrServer<TestDocWithNullable>(basicSolr, mapper, validationManager); string xml = null; With.Mocks(mocks) .Expecting(() => { Expect.On(connection) .Call(connection.Post(null, null)) .IgnoreArguments() .Do(new Writer(delegate(string u, string s) { Console.WriteLine(s); xml = s; return EmbeddedResource.GetEmbeddedString(GetType(), "Resources.response.xml"); })); }) .Verify(() => { solr.Add(new TestDocWithNullable()); Assert.AreEqual("<add><doc /></add>", xml); }); }
public void FacetFieldQuery() { var mocks = new MockRepository(); var query = new Dictionary<string, string>(); query["q"] = "*:*"; query["facet"] = "true"; query["facet.field"] = "cat"; query["rows"] = "0"; var connection = new MockConnection(query); var resultParser = mocks.StrictMock<ISolrQueryResultParser<TestDocumentWithUniqueKey>>(); var mapper = mocks.StrictMock<IReadOnlyMappingManager>(); var validationManager = mocks.StrictMock<IMappingValidator>(); var docSerializer = mocks.StrictMock<ISolrDocumentSerializer<TestDocumentWithUniqueKey>>(); With.Mocks(mocks).Expecting(() => { Expect.On(resultParser) .Call(resultParser.Parse("")) .IgnoreArguments() .Repeat.Once() .Return(new SolrQueryResults<TestDocumentWithUniqueKey> { FacetFields = new Dictionary<string, ICollection<KeyValuePair<string, int>>> { { "cat", new List<KeyValuePair<string, int>> { new KeyValuePair<string, int>("electronics", 5), new KeyValuePair<string, int>("hard drive", 3), } } } }); }).Verify(() => { var querySerializer = new DefaultQuerySerializer(new DefaultFieldSerializer()); var facetQuerySerializer = new DefaultFacetQuerySerializer(querySerializer, new DefaultFieldSerializer()); var queryExecuter = new SolrQueryExecuter<TestDocumentWithUniqueKey>(resultParser, connection, querySerializer, facetQuerySerializer); var basicSolr = new SolrBasicServer<TestDocumentWithUniqueKey>(connection, queryExecuter, docSerializer, null, null, null, null, null); var solr = new SolrServer<TestDocumentWithUniqueKey>(basicSolr, mapper, validationManager); var r = solr.FacetFieldQuery(new SolrFacetFieldQuery("cat")); Assert.AreEqual(2, r.Count); Assert.AreEqual("electronics", r.First().Key); }); }
public void FacetQuery() { var mocks = new MockRepository(); var query = new Dictionary<string, string>(); query["q"] = ""; query["rows"] = SolrQueryExecuter<TestDocumentWithUniqueKey>.ConstDefaultRows.ToString(); query["facet"] = "true"; query["facet.query"] = "id:1"; var connection = new MockConnection(query); var parser = mocks.StrictMock<ISolrQueryResultParser<TestDocumentWithUniqueKey>>(); var docSerializer = mocks.StrictMock<ISolrDocumentSerializer<TestDocumentWithUniqueKey>>(); var querySerializer = new DefaultQuerySerializer(new DefaultFieldSerializer()); var facetQuerySerializer = new DefaultFacetQuerySerializer(querySerializer, new DefaultFieldSerializer()); With.Mocks(mocks).Expecting(() => { Expect.On(parser) .Call(parser.Parse(null)) .IgnoreArguments() .Return(new SolrQueryResults<TestDocumentWithUniqueKey>()); }).Verify(() => { var executer = new SolrQueryExecuter<TestDocumentWithUniqueKey>(parser, connection, querySerializer, facetQuerySerializer); var solr = new SolrBasicServer<TestDocumentWithUniqueKey>(connection, executer, docSerializer, null, null, null, null, null); var r = solr.Query(new SolrQuery(""), new QueryOptions { Facet = new FacetParameters { Queries = new ISolrFacetQuery[] { new SolrFacetQuery(new SolrQuery("id:1")), }, } }); }); }
public void HighlightingWithoutFieldsOutputsPrePost() { const string afterTerm = "after"; const string beforeTerm = "before"; var q = new Dictionary<string, string>(); q["q"] = ""; q["rows"] = SolrQueryExecuter<TestDocument>.ConstDefaultRows.ToString(); q["hl"] = "true"; q["hl.tag.pre"] = beforeTerm; q["hl.tag.post"] = afterTerm; q["hl.useFastVectorHighlighter"] = "true"; var conn = new MockConnection(q); var querySerializer = new SolrQuerySerializerStub(""); var parser = new MSolrAbstractResponseParser<TestDocument>(); parser.parse &= x => x.Stub(); var queryExecuter = new SolrQueryExecuter<TestDocument>(parser, conn, querySerializer, null, null); queryExecuter.Execute(new SolrQuery(""), new QueryOptions { Highlight = new HighlightingParameters { AfterTerm = afterTerm, BeforeTerm = beforeTerm, UseFastVectorHighlighter = true, } }); }
public void QueryWithSortAndPagination() { const string qstring = "id:123"; const int start = 10; const int rows = 20; var mocks = new MockRepository(); var query = new Dictionary<string, string>(); query["q"] = qstring; query["start"] = start.ToString(); query["rows"] = rows.ToString(); query["sort"] = "id asc,name desc"; var connection = new MockConnection(query); var parser = mocks.StrictMock<ISolrQueryResultParser<TestDocumentWithUniqueKey>>(); var docSerializer = mocks.StrictMock<ISolrDocumentSerializer<TestDocumentWithUniqueKey>>(); var querySerializer = mocks.StrictMock<ISolrQuerySerializer>(); With.Mocks(mocks).Expecting(() => { Expect.On(querySerializer) .Call(querySerializer.Serialize(null)) .IgnoreArguments() .Return(qstring); Expect.On(parser) .Call(parser.Parse(null)) .IgnoreArguments() .Return(new SolrQueryResults<TestDocumentWithUniqueKey>()); }).Verify(() => { var executer = new SolrQueryExecuter<TestDocumentWithUniqueKey>(parser, connection, querySerializer, null); var solr = new SolrBasicServer<TestDocumentWithUniqueKey>(connection, executer, docSerializer, null, null, null, null, null); var r = solr.Query(new SolrQuery(qstring), new QueryOptions { Start = start, Rows = rows, OrderBy = new[] { new SortOrder("id", Order.ASC), new SortOrder("name", Order.DESC) } }); }); }
public void TermsSingleField() { var queryExecuter = new SolrQueryExecuter<TestDocument>(null, null, null, null, null); var p = queryExecuter.GetTermsParameters(new QueryOptions { Terms = new TermsParameters("text") { Limit = 10, Lower = "lower", LowerInclude = true, MaxCount = 10, MinCount = 0, Prefix = "pre", Raw = true, Regex = "regex", RegexFlag = new[] { RegexFlag.CanonEq, RegexFlag.CaseInsensitive }, Sort = TermsSort.Count, Upper = "upper", UpperInclude = true }, }).ToList(); Assert.Contains(p, KV.Create("terms", "true")); Assert.Contains(p, KV.Create("terms.fl", "text")); Assert.Contains(p, KV.Create("terms.lower", "lower")); Assert.Contains(p, KV.Create("terms.lower.incl", "true")); Assert.Contains(p, KV.Create("terms.maxcount", "10")); Assert.Contains(p, KV.Create("terms.mincount", "0")); Assert.Contains(p, KV.Create("terms.prefix", "pre")); Assert.Contains(p, KV.Create("terms.raw", "true")); Assert.Contains(p, KV.Create("terms.regex", "regex")); Assert.Contains(p, KV.Create("terms.regex.flag", RegexFlag.CanonEq.ToString())); Assert.Contains(p, KV.Create("terms.regex.flag", RegexFlag.CaseInsensitive.ToString())); Assert.Contains(p, KV.Create("terms.sort", "count")); Assert.Contains(p, KV.Create("terms.upper", "upper")); Assert.Contains(p, KV.Create("terms.upper.incl", "true")); }