public void Add()
{
var mocks = new MockRepository();
var connection = mocks.StrictMock<ISolrConnection>();
var executer = mocks.StrictMock<ISolrQueryExecuter<TestDocumentWithoutUniqueKey>>();
var headerParser = mocks.StrictMock<ISolrHeaderResponseParser>();
var docSerializer = new SolrDocumentSerializer<TestDocumentWithoutUniqueKey>(new AttributesMappingManager(), new DefaultFieldSerializer());
With.Mocks(mocks)
.Expecting(() => {
Expect.On(connection)
.Call(connection.Post("/update", "<add><doc /></add>"))
.Repeat.Once()
.Return(EmbeddedResource.GetEmbeddedString(GetType(), "Resources.response.xml"));
Expect.On(headerParser)
.Call(headerParser.Parse(null))
.IgnoreArguments()
.Return(new ResponseHeader());
})
.Verify(() => {
var ops = new SolrBasicServer<TestDocumentWithoutUniqueKey>(connection, executer, docSerializer, null, headerParser, null, null, null);
ops.AddWithBoost(new[] {
new KeyValuePair<TestDocumentWithoutUniqueKey, double?>(new TestDocumentWithoutUniqueKey(), null),
}, null);
});
}
public void AddWithBoost()
{
var mocks = new MockRepository();
var connection = mocks.CreateMock<ISolrConnection>();
var executer = mocks.CreateMock<ISolrQueryExecuter<TestDocumentWithoutUniqueKey>>();
var docSerializer = new SolrDocumentSerializer<TestDocumentWithoutUniqueKey>(new AttributesMappingManager(), new DefaultFieldSerializer());
With.Mocks(mocks)
.Expecting(() => Expect.Call(connection.Post("/update", "<add><doc boost=\"2.1\" /></add>"))
.Repeat.Once()
.Return(null))
.Verify(() => {
var ops = new SolrBasicServer<TestDocumentWithoutUniqueKey>(connection, executer, docSerializer);
ops.AddWithBoost(new[] {new KeyValuePair<TestDocumentWithoutUniqueKey, double?>(new TestDocumentWithoutUniqueKey(), 2.1),});
});
}
public void FilterQueries()
{
var conn = new MockConnection(new Dictionary<string, string> {
{"fq", "id:0"},
{"q", "*:*"},
{"rows", "100000000"},
});
var mocks = new MockRepository();
var queryExec = mocks.StrictMock<ISolrQueryExecuter<Document>>();
var docSerializer = mocks.StrictMock<ISolrDocumentSerializer<Document>>();
ISolrBasicReadOnlyOperations<Document> solr = new SolrBasicServer<Document>(conn, queryExec, docSerializer, null, null, null, null, null);
solr.Query(SolrQuery.All, new QueryOptions {
FilterQueries = new[] {new SolrQuery("id:0")},
});
}
public void AddWithParameters() {
var xml = EmbeddedResource.GetEmbeddedString(GetType(), "Resources.response.xml");
var connection = new MSolrConnection();
connection.post += (url, content) => {
Assert.AreEqual("/update", url);
Assert.AreEqual("<add commitWithin=\"4343\" overwrite=\"false\"><doc /></add>", content);
return xml;
};
var docSerializer = new SolrDocumentSerializer<TestDocumentWithoutUniqueKey>(new AttributesMappingManager(), new DefaultFieldSerializer());
var headerParser = new MSolrHeaderResponseParser();
headerParser.parse = headerParser.parse.Return(null);
var ops = new SolrBasicServer<TestDocumentWithoutUniqueKey>(connection, null, docSerializer, null, headerParser, null, null, null);
var parameters = new AddParameters { CommitWithin = 4343, Overwrite = false };
ops.AddWithBoost(new[] { new KeyValuePair<TestDocumentWithoutUniqueKey, double?>(new TestDocumentWithoutUniqueKey(), null), }, parameters);
Assert.AreEqual(1, connection.post.Calls);
}
public void AddWithBoost()
{
var connection = new MSolrConnection();
connection.post += (url, content) => {
Assert.AreEqual("/update", url);
Assert.AreEqual("<add><doc boost=\"2.1\" /></add>", content);
return EmbeddedResource.GetEmbeddedString(GetType(), "Resources.response.xml");
};
var docSerializer = new SolrDocumentSerializer<TestDocumentWithoutUniqueKey>(new AttributesMappingManager(), new DefaultFieldSerializer());
var headerParser = new MSolrHeaderResponseParser();
headerParser.parse = headerParser.parse.Return(null);
var ops = new SolrBasicServer<TestDocumentWithoutUniqueKey>(connection, null, docSerializer, null, headerParser, null, null, null);
ops.AddWithBoost(new[] { new KeyValuePair<TestDocumentWithoutUniqueKey, double?>(new TestDocumentWithoutUniqueKey(), 2.1), }, null);
Assert.AreEqual(1, connection.post.Calls);
}
public void Add() {
var xml = EmbeddedResource.GetEmbeddedString(GetType(), "Resources.response.xml");
var connection = new MSolrConnection();
connection.post = connection.post
.Expect(1)
.Args("/update", "<add><doc /></add>")
.Return(xml);
var headerParser = new MSolrHeaderResponseParser();
headerParser.parse = headerParser.parse.Return(null);
var docSerializer = new SolrDocumentSerializer<TestDocumentWithoutUniqueKey>(new AttributesMappingManager(), new DefaultFieldSerializer());
var ops = new SolrBasicServer<TestDocumentWithoutUniqueKey>(connection, null, docSerializer, null, headerParser, null, null, null);
ops.AddWithBoost(new[] {
new KeyValuePair<TestDocumentWithoutUniqueKey, double?>(new TestDocumentWithoutUniqueKey(), null),
}, null);
connection.post.Verify();
}
public void QueryWithSortAndPagination()
{
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() },
{ "sort", "id asc,name desc" },
};
Assert.AreElementsEqualIgnoringOrder(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,
OrderBy = new[] {
new SortOrder("id", Order.ASC),
new SortOrder("name", Order.DESC)
}
});
Assert.AreEqual(1, connection.get.Calls);
}
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, null);
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 FacetField()
{
var mocks = new MockRepository();
var query = new Dictionary <string, string>();
query["q"] = "";
query["rows"] = SolrQueryExecuter <TestDocumentWithUniqueKey> .ConstDefaultRows.ToString();
query["facet"] = "true";
query["facet.field"] = "id";
query["f.id.facet.limit"] = "3";
var connection = new MockConnection(query);
var parser = mocks.StrictMock <ISolrQueryResultParser <TestDocumentWithUniqueKey> >();
var docSerializer = mocks.StrictMock <ISolrDocumentSerializer <TestDocumentWithUniqueKey> >();
var querySerializer = mocks.DynamicMock <ISolrQuerySerializer>();
var facetQuerySerializer = new DefaultFacetQuerySerializer(querySerializer, new DefaultFieldSerializer());
With.Mocks(mocks).Expecting(() => {
Expect.On(querySerializer)
.Call(querySerializer.Serialize(null))
.IgnoreArguments()
.Return("");
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 SolrFacetFieldQuery("id")
{
Limit = 3
},
},
}
});
});
}
public void Collection()
{
var conn = new MockConnection(new Dictionary<string, string> {
{"fq", "id:0"},
{"q", "*:*"},
{"rows", "100000000"},
});
var mocks = new MockRepository();
var queryExec = mocks.StrictMock<ISolrQueryExecuter<Document>>();
var docSerializer = mocks.StrictMock<ISolrDocumentSerializer<Document>>();
ISolrBasicReadOnlyOperations<Document> solr = new SolrBasicServer<Document>(conn, queryExec, docSerializer, null, null, null, null, null);
var linqQuery = from doc in solr.AsQueryable()
where doc.Categories.AnyItem() == "cat1"
select doc;
QueryOptions qo;
var resDocs = ((IQueryableSolrNet<Document>)linqQuery).GetSolrQuery(out qo);
Assert.AreEqual("(cat:cat1)", resDocs.Query);
}
public void Boosting()
{
var conn = new MockConnection(new Dictionary<string, string> {
{"fq", "id:0"},
{"q", "*:*"},
{"rows", "100000000"},
});
var mocks = new MockRepository();
var queryExec = mocks.StrictMock<ISolrQueryExecuter<Document>>();
var docSerializer = mocks.StrictMock<ISolrDocumentSerializer<Document>>();
ISolrBasicReadOnlyOperations<Document> solr = new SolrBasicServer<Document>(conn, queryExec, docSerializer, null, null, null, null, null);
var linqQuery = from doc in solr.AsQueryable()
where (doc.Name == "john").Boost(10)
select doc;
QueryOptions qo;
var resDocs = ((IQueryableSolrNet<Document>)linqQuery).GetSolrQuery(out qo);
Assert.AreEqual("(name:john)^10", resDocs.Query);
}
public void AndsOrs()
{
var conn = new MockConnection(new Dictionary<string, string> {
{"fq", "id:0"},
{"q", "*:*"},
{"rows", "100000000"},
});
var mocks = new MockRepository();
var queryExec = mocks.StrictMock<ISolrQueryExecuter<Document>>();
var docSerializer = mocks.StrictMock<ISolrDocumentSerializer<Document>>();
ISolrBasicReadOnlyOperations<Document> solr = new SolrBasicServer<Document>(conn, queryExec, docSerializer, null, null, null, null, null);
var linqQuery = from doc in solr.AsQueryable()
where doc.DefaultFieldEquals("aa") && (doc.Price >= 1 || doc.Price <= 11)
select doc;
QueryOptions qo;
var resDocs = ((IQueryableSolrNet<Document>)linqQuery).GetSolrQuery(out qo);
Assert.AreEqual("(aa AND ((price:[1 TO *]) OR (price:[* TO 11])))", resDocs.Query);
}
public void DeleteByMultipleId()
{
var connection = new MSolrConnection();
connection.post += (url, content) => {
Assert.AreEqual("/update", url);
Assert.AreEqual("<delete><id>0</id><id>0</id></delete>", content);
return(EmbeddedResource.GetEmbeddedString(GetType(), "Resources.response.xml"));
};
var headerParser = new MSolrHeaderResponseParser();
headerParser.parse += _ => null;
var basic = new SolrBasicServer <TestDocumentWithUniqueKey>(connection, null, null, null, headerParser, null, null, null);
var ops = new SolrServer <TestDocumentWithUniqueKey>(basic, new AttributesMappingManager(), null);
ops.Delete(new[] {
new TestDocumentWithUniqueKey(),
new TestDocumentWithUniqueKey(),
});
Assert.AreEqual(1, connection.post.Calls);
}
public void OptimizeWithOptions()
{
var connection = new MSolrConnection();
connection.post += (url, content) => {
Assert.AreEqual("/update", url);
Assert.AreEqual("<optimize waitSearcher=\"true\" waitFlush=\"true\" />", content);
return(EmbeddedResource.GetEmbeddedString(GetType(), "Resources.response.xml"));
};
var headerParser = new MSolrHeaderResponseParser();
headerParser.parse += _ => null;
var ops = new SolrBasicServer <TestDocumentWithoutUniqueKey>(connection, null, null, null, headerParser, null, null, null);
ops.Optimize(new CommitOptions {
WaitFlush = true, WaitSearcher = true
});
Assert.AreEqual(1, connection.post.Calls);
}
public async Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
{
try
{
var url = $"{_options.Uri}/{_options.Core}";
if (!_connections.TryGetValue(url, out SolrConnection solrConnection))
{
solrConnection = new SolrConnection(url);
solrConnection.Timeout = (int)_options.Timeout.TotalMilliseconds;
if (!_connections.TryAdd(url, solrConnection))
{
solrConnection = _connections[url];
}
}
var server = new SolrBasicServer <string>(
solrConnection,
queryExecuter: null,
documentSerializer: null,
schemaParser: null,
headerParser: null,
querySerializer: null,
dihStatusParser: null,
extractResponseParser: null);
var result = await server.PingAsync();
var isSuccess = result.Status == 0;
return(isSuccess
? HealthCheckResult.Healthy()
: new HealthCheckResult(context.Registration.FailureStatus));
}
catch (Exception ex)
{
return(new HealthCheckResult(context.Registration.FailureStatus, exception: ex));
}
}
public void FacetField()
{
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.field", "id" },
{ "f.id.facet.limit", "3" },
};
CollectionAssert.AreEquivalent(expectedParams, param);
return(EmbeddedResource.GetEmbeddedString(GetType(), "Resources.response.xml"));
};
var parser = new MSolrAbstractResponseParser <TestDocumentWithUniqueKey>();
parser.parse &= x => x.Stub();
var querySerializer = new MSolrQuerySerializer();
querySerializer.serialize += _ => "";
var facetQuerySerializer = new DefaultFacetQuerySerializer(querySerializer, new DefaultFieldSerializer());
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 SolrFacetFieldQuery("id")
{
Limit = 3
},
},
}
});
Assert.AreEqual(1, connection.get.Calls);
}
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 AddWithParameters()
{
var xml = EmbeddedResource.GetEmbeddedString(GetType(), "Resources.response.xml");
var connection = new MSolrConnection();
connection.post += (url, content) => {
Assert.AreEqual("/update", url);
Assert.AreEqual("<add commitWithin=\"4343\" overwrite=\"false\"><doc /></add>", content);
return(xml);
};
var docSerializer = new SolrDocumentSerializer <TestDocumentWithoutUniqueKey>(new AttributesMappingManager(), new DefaultFieldSerializer());
var headerParser = new MSolrHeaderResponseParser();
headerParser.parse = headerParser.parse.Return(null);
var ops = new SolrBasicServer <TestDocumentWithoutUniqueKey>(connection, null, docSerializer, null, headerParser, null, null, null);
var parameters = new AddParameters {
CommitWithin = 4343, Overwrite = false
};
ops.AddWithBoost(new[] { new KeyValuePair <TestDocumentWithoutUniqueKey, double?>(new TestDocumentWithoutUniqueKey(), null), }, parameters);
Assert.AreEqual(1, connection.post.Calls);
}
public void Add()
{
var xml = EmbeddedResource.GetEmbeddedString(GetType(), "Resources.response.xml");
var connection = new MSolrConnection();
connection.post = connection.post
.Expect(1)
.Args("/update", "<add><doc /></add>")
.Return(xml);
var headerParser = new MSolrHeaderResponseParser();
headerParser.parse = headerParser.parse.Return(null);
var docSerializer = new SolrDocumentSerializer <TestDocumentWithoutUniqueKey>(new AttributesMappingManager(), new DefaultFieldSerializer());
var ops = new SolrBasicServer <TestDocumentWithoutUniqueKey>(connection, null, docSerializer, null, headerParser, null, null, null);
ops.AddWithBoost(new[] {
new KeyValuePair <TestDocumentWithoutUniqueKey, double?>(new TestDocumentWithoutUniqueKey(), null),
}, null);
connection.post.Verify();
}
public void QueryWithSort()
{
const string qstring = "id:123";
var connection = new MSolrConnection();
connection.get += new MFunc <string, IEnumerable <KeyValuePair <string, string> >, string>((url, param) => {
Assert.Equal("/select", url);
var expectedParams = new Dictionary <string, string> {
{ "q", qstring },
{ "rows", SolrQueryExecuter <TestDocumentWithUniqueKey> .ConstDefaultRows.ToString() },
{ "sort", "id asc,name desc" },
};
Assert.Equal(expectedParams, param); //should ignore order
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 {
OrderBy = new[] {
new SortOrder("id", Order.ASC),
new SortOrder("name", Order.DESC)
}
});
Assert.Equal(1, connection.get.Calls);
}
public void MoreLikeThisHandlerQuery()
{
const string qstring = "id:123";
var connection = new MSolrConnection();
connection.get += (url, param) => {
Assert.AreEqual("/mlt", url);
var expectedParams = new Dictionary <string, string> {
{ "q", qstring },
{ "rows", SolrQueryExecuter <TestDocumentWithUniqueKey> .ConstDefaultRows.ToString() },
{ "mlt", "true" },
{ "mlt.fl", "id" },
{ "mlt.match.include", "true" },
};
CollectionAssert.AreEquivalent(expectedParams, param);
return(EmbeddedResource.GetEmbeddedString(GetType(), "Resources.responseWithInterestingTermsDetails.xml"));
};
var querySerializer = new MSolrQuerySerializer();
querySerializer.serialize &= x => x.Return(qstring);
var mlthParser = new MSolrMoreLikeThisHandlerQueryResultsParser <TestDocumentWithUniqueKey>();
mlthParser.parse += _ => new SolrMoreLikeThisHandlerResults <TestDocumentWithUniqueKey>();
var executer = new SolrQueryExecuter <TestDocumentWithUniqueKey>(null, connection, querySerializer, null, mlthParser);
var solr = new SolrBasicServer <TestDocumentWithUniqueKey>(connection, executer, null, null, null, null, null, null);
var r = solr.MoreLikeThis(new SolrMoreLikeThisHandlerQuery(new SolrQuery(qstring)), new MoreLikeThisHandlerQueryOptions(new MoreLikeThisHandlerParameters(new[] { "id" })
{
MatchInclude = true
}));
Assert.AreEqual(1, connection.get.Calls);
}
public void Extract()
{
var parameters = new ExtractParameters(null, "1", "test.doc");
var connection = new MSolrConnection();
connection.postStream += (url, contentType, content, param) => {
Assert.AreEqual("/update/extract", url);
Assert.AreEqual(parameters.Content, content);
var expectedParams = new[] {
KV.Create("literal.id", parameters.Id),
KV.Create("resource.name", parameters.ResourceName),
};
CollectionAssert.AreEquivalent(expectedParams, param);
return(EmbeddedResource.GetEmbeddedString(GetType(), "Resources.responseWithExtractContent.xml"));
};
var docSerializer = new SolrDocumentSerializer <TestDocumentWithoutUniqueKey>(new AttributesMappingManager(), new DefaultFieldSerializer());
var extractResponseParser = new MSolrExtractResponseParser {
parse = _ => new ExtractResponse(null)
};
var ops = new SolrBasicServer <TestDocumentWithoutUniqueKey>(connection, null, docSerializer, null, null, null, null, extractResponseParser);
ops.Extract(parameters);
Assert.AreEqual(1, connection.postStream.Calls);
}
public void AddWithBoost()
{
var mocks = new MockRepository();
var connection = mocks.StrictMock <ISolrConnection>();
var executer = mocks.StrictMock <ISolrQueryExecuter <TestDocumentWithoutUniqueKey> >();
var headerParser = mocks.StrictMock <ISolrHeaderResponseParser>();
var docSerializer = new SolrDocumentSerializer <TestDocumentWithoutUniqueKey>(new AttributesMappingManager(), new DefaultFieldSerializer());
With.Mocks(mocks)
.Expecting(() => {
Expect.On(connection)
.Call(connection.Post("/update", "<add><doc boost=\"2.1\" /></add>"))
.Repeat.Once()
.Return(EmbeddedResource.GetEmbeddedString(GetType(), "Resources.response.xml"));
Expect.On(headerParser)
.Call(headerParser.Parse(null))
.IgnoreArguments()
.Return(new ResponseHeader());
})
.Verify(() => {
var ops = new SolrBasicServer <TestDocumentWithoutUniqueKey>(connection, executer, docSerializer, null, headerParser, null, null, null);
ops.AddWithBoost(new[] { new KeyValuePair <TestDocumentWithoutUniqueKey, double?>(new TestDocumentWithoutUniqueKey(), 2.1), }, null);
});
}
public void CommitWithOptions()
{
var mocks = new MockRepository();
var connection = mocks.StrictMock <ISolrConnection>();
var headerParser = mocks.StrictMock <ISolrHeaderResponseParser>();
var executer = mocks.StrictMock <ISolrQueryExecuter <TestDocumentWithoutUniqueKey> >();
var docSerializer = mocks.StrictMock <ISolrDocumentSerializer <TestDocumentWithoutUniqueKey> >();
With.Mocks(mocks)
.Expecting(() => {
Expect.On(connection)
.Call(connection.Post("/update", "<commit waitSearcher=\"true\" waitFlush=\"true\" />"))
.Repeat.Once()
.Return(EmbeddedResource.GetEmbeddedString(GetType(), "Resources.response.xml"));
Expect.On(headerParser)
.Call(headerParser.Parse(null))
.IgnoreArguments()
.Return(new ResponseHeader());
})
.Verify(() => {
var ops = new SolrBasicServer <TestDocumentWithoutUniqueKey>(connection, executer, docSerializer, null, headerParser, null, null, null);
ops.Commit(new CommitOptions());
});
}
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 Optimize()
{
var connection = new MSolrConnection();
connection.post += (url, content) => {
Assert.AreEqual("/update", url);
Assert.AreEqual("<optimize />", content);
return EmbeddedResource.GetEmbeddedString(GetType(), "Resources.response.xml");
};
var headerParser = new MSolrHeaderResponseParser();
headerParser.parse += _ => null;
var ops = new SolrBasicServer<TestDocumentWithoutUniqueKey>(connection, null, null, null, headerParser, null, null, null);
ops.Optimize(null);
Assert.AreEqual(1, connection.post.Calls);
}
public void MoreLikeThisHandlerQuery()
{
const string qstring = "id:123";
var connection = new MSolrConnection();
connection.get += (url, param) => {
Assert.AreEqual("/mlt", url);
var expectedParams = new Dictionary<string, string> {
{"q", qstring},
{"rows", SolrQueryExecuter<TestDocumentWithUniqueKey>.ConstDefaultRows.ToString() },
{"mlt", "true"},
{"mlt.fl", "id"},
{"mlt.match.include", "true"},
};
Assert.AreElementsEqualIgnoringOrder(expectedParams, param);
return EmbeddedResource.GetEmbeddedString(GetType(), "Resources.responseWithInterestingTermsDetails.xml");
};
var querySerializer = new MSolrQuerySerializer();
querySerializer.serialize &= x => x.Return(qstring);
var mlthParser = new MSolrMoreLikeThisHandlerQueryResultsParser<TestDocumentWithUniqueKey>();
mlthParser.parse += _ => new SolrMoreLikeThisHandlerResults<TestDocumentWithUniqueKey>();
var executer = new SolrQueryExecuter<TestDocumentWithUniqueKey>(null, connection, querySerializer, null, mlthParser);
var solr = new SolrBasicServer<TestDocumentWithUniqueKey>(connection, executer, null, null, null, null, null, null);
var r = solr.MoreLikeThis(new SolrMoreLikeThisHandlerQuery(new SolrQuery(qstring)), new MoreLikeThisHandlerQueryOptions(new MoreLikeThisHandlerParameters(new[] { "id" }) { MatchInclude = true }));
Assert.AreEqual(1, connection.get.Calls);
}
public void QueryWithSortAndPagination()
{
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()},
{"sort", "id asc,name desc"},
};
Assert.AreElementsEqualIgnoringOrder(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,
OrderBy = new[] {
new SortOrder("id", Order.ASC),
new SortOrder("name", Order.DESC)
}
});
Assert.AreEqual(1, connection.get.Calls);
}
public void DeleteByQuery()
{
var mocks = new MockRepository();
var connection = mocks.StrictMock<ISolrConnection>();
var headerParser = mocks.StrictMock<ISolrHeaderResponseParser>();
var executer = mocks.StrictMock<ISolrQueryExecuter<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("id:123");
Expect.On(connection)
.Call(connection.Post("/update", "<delete><query>id:123</query></delete>"))
.Repeat.Once()
.Return(EmbeddedResource.GetEmbeddedString(GetType(), "Resources.response.xml"));
Expect.On(headerParser)
.Call(headerParser.Parse(null))
.IgnoreArguments()
.Return(new ResponseHeader());
})
.Verify(() => {
var ops = new SolrBasicServer<TestDocumentWithUniqueKey>(connection, executer, docSerializer, null, headerParser, querySerializer, null, null);
ops.Delete(null, new SolrQuery("id:123"));
});
}
public void CommitWithOptions2_WaitSearcher()
{
var mocks = new MockRepository();
var connection = mocks.StrictMock<ISolrConnection>();
var headerParser = mocks.StrictMock<ISolrHeaderResponseParser>();
var executer = mocks.StrictMock<ISolrQueryExecuter<TestDocumentWithoutUniqueKey>>();
var docSerializer = mocks.StrictMock<ISolrDocumentSerializer<TestDocumentWithoutUniqueKey>>();
With.Mocks(mocks)
.Expecting(() => {
Expect.On(connection)
.Call(connection.Post("/update", "<commit waitSearcher=\"false\" waitFlush=\"true\" />"))
.Repeat.Once()
.Return(EmbeddedResource.GetEmbeddedString(GetType(), "Resources.response.xml"));
Expect.On(headerParser)
.Call(headerParser.Parse(null))
.IgnoreArguments()
.Return(new ResponseHeader());
})
.Verify(() => {
var ops = new SolrBasicServer<TestDocumentWithoutUniqueKey>(connection, executer, docSerializer, null, headerParser, null, null, null);
ops.Commit(new CommitOptions { WaitSearcher = false });
});
}
public void OptimizeWithWaitOptions()
{
var mocks = new MockRepository();
var connection = mocks.StrictMock<ISolrConnection>();
var headerParser = mocks.DynamicMock<ISolrHeaderResponseParser>();
var executer = mocks.StrictMock<ISolrQueryExecuter<TestDocumentWithoutUniqueKey>>();
var docSerializer = mocks.StrictMock<ISolrDocumentSerializer<TestDocumentWithoutUniqueKey>>();
With.Mocks(mocks)
.Expecting(() => Expect.On(connection)
.Call(connection.Post("/update", "<optimize waitSearcher=\"true\" waitFlush=\"true\" />"))
.Repeat.Once()
.Return(EmbeddedResource.GetEmbeddedString(GetType(), "Resources.response.xml")))
.Verify(() => {
var ops = new SolrBasicServer<TestDocumentWithoutUniqueKey>(connection, executer, docSerializer, null, headerParser, null, null, null);
ops.Optimize(new CommitOptions {WaitFlush = true, WaitSearcher = true});
});
}
public void DeleteByMultipleId()
{
var mocks = new MockRepository();
var connection = mocks.CreateMock<ISolrConnection>();
var executer = mocks.CreateMock<ISolrQueryExecuter<TestDocumentWithUniqueKey>>();
var docSerializer = mocks.CreateMock<ISolrDocumentSerializer<TestDocumentWithUniqueKey>>();
With.Mocks(mocks)
.Expecting(() => Expect.Call(connection.Post("/update", "<delete><id>0</id><id>0</id></delete>"))
.Repeat.Once()
.Return(null))
.Verify(delegate {
var basic = new SolrBasicServer<TestDocumentWithUniqueKey>(connection, executer, docSerializer);
var ops = new SolrServer<TestDocumentWithUniqueKey>(basic, new AttributesMappingManager());
ops.Delete(new[] {
new TestDocumentWithUniqueKey(),
new TestDocumentWithUniqueKey(),
});
});
}
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"},
};
Assert.AreElementsEqualIgnoringOrder(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 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 Extract()
{
var parameters = new ExtractParameters(null, "1", "test.doc");
var connection = new MSolrConnection();
connection.postStream += (url, contentType, content, param) => {
Assert.AreEqual("/update/extract", url);
Assert.AreEqual(parameters.Content, content);
var expectedParams = new[] {
KV.Create("literal.id", parameters.Id),
KV.Create("resource.name", parameters.ResourceName),
};
Assert.AreElementsEqualIgnoringOrder(expectedParams, param);
return EmbeddedResource.GetEmbeddedString(GetType(), "Resources.responseWithExtractContent.xml");
};
var docSerializer = new SolrDocumentSerializer<TestDocumentWithoutUniqueKey>(new AttributesMappingManager(), new DefaultFieldSerializer());
var extractResponseParser = new MSolrExtractResponseParser {
parse = _ => new ExtractResponse(null)
};
var ops = new SolrBasicServer<TestDocumentWithoutUniqueKey>(connection, null, docSerializer, null, null, null, null, extractResponseParser);
ops.Extract(parameters);
Assert.AreEqual(1, connection.postStream.Calls);
}
public void DeleteByMultipleId()
{
var mocks = new MockRepository();
var connection = mocks.StrictMock<ISolrConnection>();
var headerParser = mocks.StrictMock<ISolrHeaderResponseParser>();
var executer = mocks.StrictMock<ISolrQueryExecuter<TestDocumentWithUniqueKey>>();
var docSerializer = mocks.StrictMock<ISolrDocumentSerializer<TestDocumentWithUniqueKey>>();
var validationManager = mocks.StrictMock<IMappingValidator>();
With.Mocks(mocks)
.Expecting(() => {
Expect.On(connection)
.Call(connection.Post("/update", "<delete><id>0</id><id>0</id></delete>"))
.Repeat.Once()
.Return(EmbeddedResource.GetEmbeddedString(GetType(), "Resources.response.xml"));
Expect.On(headerParser)
.Call(headerParser.Parse(null))
.IgnoreArguments()
.Return(new ResponseHeader());
})
.Verify(() => {
var basic = new SolrBasicServer<TestDocumentWithUniqueKey>(connection, executer, docSerializer, null, headerParser, null, null, null);
var ops = new SolrServer<TestDocumentWithUniqueKey>(basic, new AttributesMappingManager(), validationManager);
ops.Delete(new[] {
new TestDocumentWithUniqueKey(),
new TestDocumentWithUniqueKey(),
});
});
}
public void CommitWithOptions()
{
var mocks = new MockRepository();
var connection = mocks.CreateMock<ISolrConnection>();
var executer = mocks.CreateMock<ISolrQueryExecuter<TestDocumentWithoutUniqueKey>>();
var docSerializer = mocks.CreateMock<ISolrDocumentSerializer<TestDocumentWithoutUniqueKey>>();
With.Mocks(mocks)
.Expecting(() => Expect.Call(connection.Post("/update", "<commit waitSearcher=\"true\" waitFlush=\"true\" />"))
.Repeat.Once()
.Return(null))
.Verify(() => {
var ops = new SolrBasicServer<TestDocumentWithoutUniqueKey>(connection, executer, docSerializer);
ops.Commit(new WaitOptions());
});
}
public void Extract()
{
var mocks = new MockRepository();
var connection = mocks.StrictMock<ISolrConnection>();
var executer = mocks.StrictMock<ISolrQueryExecuter<TestDocumentWithoutUniqueKey>>();
var headerParser = mocks.StrictMock<ISolrHeaderResponseParser>();
var extractResponseParser = mocks.StrictMock<ISolrExtractResponseParser>();
var docSerializer = new SolrDocumentSerializer<TestDocumentWithoutUniqueKey>(new AttributesMappingManager(), new DefaultFieldSerializer());
var parameters = new ExtractParameters(null, "1", "test.doc");
With.Mocks(mocks)
.Expecting(() => {
Expect.On(connection)
.Call(connection.PostStream("/update/extract", null, parameters.Content, new List<KeyValuePair<string, string>> {
new KeyValuePair<string, string>("literal.id", parameters.Id),
new KeyValuePair<string, string>("resource.name", parameters.ResourceName),
}))
.Repeat.Once()
.Return(EmbeddedResource.GetEmbeddedString(GetType(), "Resources.responseWithExtractContent.xml"));
Expect.On(extractResponseParser)
.Call(extractResponseParser.Parse(null))
.IgnoreArguments()
.Return(new ExtractResponse(null));
})
.Verify(() => {
var ops = new SolrBasicServer<TestDocumentWithoutUniqueKey>(connection, executer, docSerializer, null, headerParser, null, null, extractResponseParser);
ops.Extract(parameters);
});
}
public void OptimizeWithWaitOptions()
{
var connection = new MSolrConnection();
connection.post += (url, content) => {
Assert.AreEqual("/update", url);
Assert.AreEqual("<optimize waitSearcher=\"true\" waitFlush=\"true\" />", content);
return EmbeddedResource.GetEmbeddedString(GetType(), "Resources.response.xml");
};
var headerParser = new MSolrHeaderResponseParser();
headerParser.parse += _ => null;
var ops = new SolrBasicServer<TestDocumentWithoutUniqueKey>(connection, null, null, null, headerParser, null, null, null);
ops.Optimize(new CommitOptions { WaitFlush = true, WaitSearcher = true });
}
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 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 DeleteByQuery()
{
var mocks = new MockRepository();
var connection = mocks.CreateMock<ISolrConnection>();
var executer = mocks.CreateMock<ISolrQueryExecuter<TestDocumentWithUniqueKey>>();
var docSerializer = mocks.CreateMock<ISolrDocumentSerializer<TestDocumentWithUniqueKey>>();
With.Mocks(mocks)
.Expecting(() => Expect.Call(connection.Post("/update", "<delete><query>id:123</query></delete>"))
.Repeat.Once()
.Return(null))
.Verify(delegate {
var ops = new SolrBasicServer<TestDocumentWithUniqueKey>(connection, executer, docSerializer);
ops.Delete(null, new SolrQuery("id:123"));
});
}
public void DeleteByQuery()
{
var connection = new MSolrConnection();
connection.post += (url, content) => {
Assert.AreEqual("/update", url);
Assert.AreEqual("<delete><query>id:123</query></delete>", content);
return EmbeddedResource.GetEmbeddedString(GetType(), "Resources.response.xml");
};
var headerParser = new MSolrHeaderResponseParser();
headerParser.parse += _ => null;
var querySerializer = new MSolrQuerySerializer();
querySerializer.serialize += _ => "id:123";
var ops = new SolrBasicServer<TestDocumentWithUniqueKey>(connection, null, null, null, headerParser, querySerializer, null, null);
ops.Delete(null, new SolrQuery("id:123"));
Assert.AreEqual(1, connection.post.Calls);
}
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 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);
});
}
