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"));
}
