public void ChainedTerms(LuceneSearch luceneSearch)
{
IQueryBuilder queryBuilder = new QueryBuilder();
queryBuilder.Setup
(
x => x.WildCard(BBCFields.Description, "a*"),
x => x.Term(BBCFields.Description, "police")
);
ExecuteAndAssert(luceneSearch, queryBuilder, 17);
}
public void Group(LuceneSearch luceneSearch)
{
IQueryBuilder queryBuilder = new QueryBuilder();
queryBuilder.Setup
(
x => x.WildCard(BBCFields.Title, "africa"),
x => x.Group().Setup
(
y => y.Term(BBCFields.Description, "africa", BooleanClause.Occur.SHOULD),
y => y.Term(BBCFields.Description, "amazing", BooleanClause.Occur.SHOULD)
)
);
ExecuteAndAssert(luceneSearch, queryBuilder, 5);
}
public void BoostedCaseInsensitiveMandatoryTerm()
{
BooleanQuery originalQuery = new BooleanQuery();
Term term = new Term("_name", "value");
TermQuery termQuery = new TermQuery(term);
originalQuery.Add(termQuery, Occur.MUST);
termQuery.Boost = 10;
string queryString = originalQuery.ToString();
QueryBuilder builder = new QueryBuilder();
builder.Setup(x => x.Term("_name", "Value", boost:10));
Query replacementQuery = builder.Build();
string newQueryString = replacementQuery.ToString();
Assert.AreEqual(queryString, newQueryString);
Console.Write(queryString);
}
public void CollectDailyCount(LuceneSearch luceneSearch)
{
IQueryBuilder queryBuilder = new QueryBuilder();
queryBuilder.Setup
(
x => x.WildCard(BBCFields.PublishDate, "*")
);
DateCollector collector = new DateCollector();
luceneSearch.Collect(queryBuilder.Build(), collector);
foreach (String day in collector.DailyCount.Keys)
{
Console.Error.WriteLine("Day: {0} had {1} documents", day, collector.DailyCount[day]);
}
Console.WriteLine();
}
public void GetByFieldValue()
{
QueryBuilder queryBuilder = new QueryBuilder();
queryBuilder.Setup(x => x.Field("title", "contact us"));
ISitecoreSearchResult sitecoreSearchResult = search.Execute(queryBuilder);
Assert.Greater(sitecoreSearchResult.TotalHits, 0);
ISitecoreItemResult sitecoreItemResult = sitecoreSearchResult.GetPagedItems(0, 10);
Console.WriteLine("Lucene Elapsed Time: {0}", sitecoreSearchResult.ElapsedTimeMs);
Console.WriteLine("Sitecore Elapsed Time: {0}", sitecoreItemResult.ElapsedTimeMs);
sitecoreItemResult.Items.ForEach(
item =>
{
Console.WriteLine(item.Name);
Assert.IsTrue(item["title"].IndexOf("contact us", StringComparison.InvariantCultureIgnoreCase) >= 0);
});
Assert.Greater(sitecoreItemResult.Items.Count, 0);
}
public void GetByLanguage()
{
QueryBuilder queryBuilder = new QueryBuilder();
Language language = Language.Parse("en");
queryBuilder.Setup(x => x.Language(language));
ISitecoreSearchResult sitecoreSearchResult = search.Execute(queryBuilder);
Assert.Greater(sitecoreSearchResult.TotalHits, 0);
ISitecoreItemResult sitecoreItemResult = sitecoreSearchResult.GetPagedItems(0, 100);
Console.WriteLine("Lucene Elapsed Time: {0}", sitecoreSearchResult.ElapsedTimeMs);
Console.WriteLine("Sitecore Elapsed Time: {0}", sitecoreItemResult.ElapsedTimeMs);
sitecoreItemResult.Items.ForEach(
item =>
{
Console.WriteLine(item.Name);
Assert.AreEqual(language, item.Language);
});
Assert.Greater(sitecoreItemResult.Items.Count, 0);
}
public void GetById()
{
QueryBuilder queryBuilder = new QueryBuilder();
ID itemId = new ID(Constants.HomeItemId);
queryBuilder.Setup(x => x.Id(itemId));
ISitecoreSearchResult sitecoreSearchResult = search.Execute(queryBuilder);
Assert.Greater(sitecoreSearchResult.TotalHits, 0);
ISitecoreItemResult sitecoreItemResult = sitecoreSearchResult.GetPagedItems(0, 10);
Console.WriteLine("Lucene Elapsed Time: {0}", sitecoreSearchResult.ElapsedTimeMs);
Console.WriteLine("Sitecore Elapsed Time: {0}", sitecoreItemResult.ElapsedTimeMs);
sitecoreItemResult.Items.ForEach(
item =>
{
Console.WriteLine(item.Name);
Assert.AreEqual(itemId, item.ID);
});
Assert.Greater(sitecoreItemResult.Items.Count, 0);
}
public void Paging()
{
QueryBuilder queryBuilder = new QueryBuilder();
queryBuilder.Setup(x => x.Ancestor(new ID(Constants.HomeItemId)));
ISitecoreSearchResult sitecoreSearchResult = search.Execute(queryBuilder);
ISitecoreItemResult sitecoreItemResult = sitecoreSearchResult.GetPagedItems(0, 9);
Assert.AreEqual(10, sitecoreItemResult.Items.Count);
ISitecoreItemResult sitecoreItemResult2 = sitecoreSearchResult.GetPagedItems(0, 19);
Assert.AreEqual(20, sitecoreItemResult2.Items.Count);
ISitecoreItemResult sitecoreItemResult3 = sitecoreSearchResult.GetPagedItems(10, 29);
Assert.AreEqual(20, sitecoreItemResult3.Items.Count);
}
public void QueryCaseSensitiveTermRange()
{
BooleanQuery originalQuery = new BooleanQuery();
TermRangeQuery termRangeQuery = new TermRangeQuery("field", "Lower", "Upper", true, true);
originalQuery.Add(termRangeQuery, Occur.MUST);
string queryString = originalQuery.ToString();
QueryBuilder builder = new QueryBuilder{CaseSensitive = true};
builder.Setup(x => x.TermRange("field", "Lower", "Upper"));
Query replacementQuery = builder.Build();
string newQueryString = replacementQuery.ToString();
Assert.AreEqual(queryString, newQueryString);
Console.Write(queryString);
}
public void Or()
{
BooleanQuery originalQuery = new BooleanQuery();
Term term = new Term("_name", "value1");
TermQuery termQuery1 = new TermQuery(term);
originalQuery.Add(termQuery1, Occur.SHOULD);
Term term2 = new Term("_name", "value2");
TermQuery termQuery2 = new TermQuery(term2);
originalQuery.Add(termQuery2, Occur.SHOULD);
string queryString = originalQuery.ToString();
QueryBuilder builder = new QueryBuilder{DefaultChildrenOccur = Matches.Sometimes};
builder.Setup
(
x => x.Term("_name", "value1"),
x => x.Term("_name", "value2")
);
Query replacementQuery1 = builder.Build();
string newQueryString1 = replacementQuery1.ToString();
Assert.AreEqual(queryString, newQueryString1);
QueryBuilder builder2 = new QueryBuilder();
builder2.Setup
(
x => x.Term("_name", "value1", Matches.Sometimes),
x => x.Term("_name", "value2", Matches.Sometimes)
);
Query replacementQuery2 = builder2.Build();
string newQueryString2 = replacementQuery2.ToString();
Assert.AreEqual(queryString, newQueryString2);
QueryBuilder builder3 = new QueryBuilder();
builder3.Setup
(
x => x.Term("_name", "value1"),
x => x.Term("_name", "value2")
);
Query replacementQuery3 = builder3.Build();
string newQueryString3 = replacementQuery3.ToString();
Assert.AreNotEqual(queryString, newQueryString3);
Console.Write(queryString);
}
public void CompositeTermPhraseWildcardTests()
{
BooleanQuery originalQuery = new BooleanQuery();
Term term = new Term("_name", "value");
TermQuery termQuery = new TermQuery(term);
originalQuery.Add(termQuery, Occur.MUST);
PhraseQuery phraseQuery = new PhraseQuery();
Term phraseTerm = new Term("_name", "phrase");
phraseQuery.Slop = 2;
phraseQuery.Add(phraseTerm);
originalQuery.Add(phraseQuery, Occur.MUST);
Term wildcardTerm = new Term("_name", "*wildcard*");
WildcardQuery wildcardQuery = new WildcardQuery(wildcardTerm);
originalQuery.Add(wildcardQuery, Occur.SHOULD);
string queryString = originalQuery.ToString();
QueryBuilder builder = new QueryBuilder();
builder.Setup
(
x => x.Term("_name", "value"),
x => x.Phrase(2).AddTerm("_name", "phrase"),
x => x.WildCard("_name", "*wildcard*", Matches.Sometimes)
);
Query replacementQuery = builder.Build();
string newQueryString = replacementQuery.ToString();
Assert.AreEqual(queryString, newQueryString);
Console.Write(queryString);
}
public void CaseSensitiveNonMandatoryKeyword()
{
QueryBuilder builder = new QueryBuilder();
BooleanQuery originalQuery = new BooleanQuery();
QueryParser rawQueryParser = new QueryParser(Version.LUCENE_29, "_name", builder.KeywordAnalyzer);
originalQuery.Add(rawQueryParser.Parse("Value"), Occur.SHOULD);
string queryString = originalQuery.ToString();
builder.Setup(x => x.Keyword("_name", "Value", Matches.Sometimes, caseSensitive: true));
Query replacementQuery = builder.Build();
string newQueryString = replacementQuery.ToString();
Assert.AreEqual(queryString, newQueryString);
Console.Write(queryString);
}
public void CaseInsensitiveKeyword()
{
QueryBuilder builder = new QueryBuilder();
BooleanQuery originalQuery = new BooleanQuery();
QueryParser rawQueryParser = new QueryParser(Version.LUCENE_29, "_name", builder.KeywordAnalyzer);
originalQuery.Add(rawQueryParser.Parse("value"), Occur.MUST);
string queryString = originalQuery.ToString();
builder.Setup(x => x.Keyword("_name", "Value"));
Query replacementQuery = builder.Build();
string newQueryString = replacementQuery.ToString();
Assert.AreEqual(queryString, newQueryString);
Console.Write(queryString);
}
public void IntegerRange()
{
BooleanQuery originalQuery = new BooleanQuery();
NumericRangeQuery numericRangeQuery = NumericRangeQuery.NewIntRange("field", 1, 0, 10, true, true);
originalQuery.Add(numericRangeQuery, BooleanClause.Occur.MUST);
string queryString = originalQuery.ToString();
QueryBuilder builder = new QueryBuilder();
builder.Setup(x => x.NumericRange("field", 0, 10));
Query replacementQuery = builder.Build();
string newQueryString = replacementQuery.ToString();
Assert.AreEqual(queryString, newQueryString);
Console.Write(queryString);
}
private void Ancestor(bool displayOutput = true)
{
QueryBuilder queryBuilder = new QueryBuilder();
queryBuilder.Setup(x => x.Ancestor(new ID(Constants.HomeItemId)));
ISitecoreSearchResult sitecoreSearchResult = search.Execute(queryBuilder);
ISitecoreItemResult sitecoreItemResult = sitecoreSearchResult.GetPagedItems(0, 9);
Assert.Greater(sitecoreSearchResult.TotalHits, 0);
Console.WriteLine("Lucene Elapsed Time: {0}", sitecoreSearchResult.ElapsedTimeMs);
Console.WriteLine("Sitecore Elapsed Time: {0}", sitecoreItemResult.ElapsedTimeMs);
if (displayOutput)
{
sitecoreItemResult.Items.ForEach(
item =>
{
Console.WriteLine(item.Name);
});
}
Assert.Greater(sitecoreItemResult.Items.Count, 0);
}
public void WildCard(LuceneSearch luceneSearch)
{
IQueryBuilder queryBuilder = new QueryBuilder();
queryBuilder.Setup(x => x.WildCard(BBCFields.Description, "a*"));
ExecuteAndAssert(luceneSearch, queryBuilder, 902);
}
public void Group(LuceneSearch luceneSearch)
{
IQueryBuilder queryBuilder = new QueryBuilder();
queryBuilder.Setup
(
x => x.WildCard(BBCFields.Title, "africa"),
x => x.Group().Setup
(
y => y.Term(BBCFields.Description, "africa", Matches.Sometimes),
y => y.Term(BBCFields.Description, "amazing", Matches.Sometimes)
)
);
ExecuteAndAssert(luceneSearch, queryBuilder, 5);
}
public void QueryCaseSensitivePhrase()
{
BooleanQuery originalQuery = new BooleanQuery();
Term term = new Term("_name", "Value");
PhraseQuery phraseQuery = new PhraseQuery();
phraseQuery.SetSlop(2);
phraseQuery.Add(term);
originalQuery.Add(phraseQuery, BooleanClause.Occur.MUST);
string queryString = originalQuery.ToString();
QueryBuilder builder = new QueryBuilder{CaseSensitive = true};
builder.Setup(x => x.Phrase(2).AddTerm(x, "_name", "Value"));
Query replacementQuery = builder.Build();
string newQueryString = replacementQuery.ToString();
Assert.AreEqual(queryString, newQueryString);
Console.Write(queryString);
}
public void CaseInsensitiveNonMandatoryWildCard()
{
BooleanQuery originalQuery = new BooleanQuery();
Term term = new Term("_name", "value*");
WildcardQuery wildcardQuery = new WildcardQuery(term);
originalQuery.Add(wildcardQuery, Occur.SHOULD);
string queryString = originalQuery.ToString();
QueryBuilder builder = new QueryBuilder();
builder.Setup(x => x.WildCard("_name", "Value*", Matches.Sometimes));
Query replacementQuery = builder.Build();
string newQueryString = replacementQuery.ToString();
Assert.AreEqual(queryString, newQueryString);
Console.Write(queryString);
}
public void MultipleSortingDescending(LuceneSearch luceneSearch)
{
IQueryBuilder queryBuilder = new QueryBuilder();
queryBuilder.Setup
(
x => x.WildCard(BBCFields.Description, "a*"),
x => x.Sort(BBCFields.SecondarySort, true),
x => x.Sort(BBCFields.Sortable, true)
);
ILuceneSearchResult result = ExecuteAndAssert(luceneSearch, queryBuilder, 902);
List<Document> documents = result.GetPagedDocuments(0, 1000);
for (var i = 1; i < documents.Count; i++)
{
string thisDocumentSortable = GetSecondarySortString(documents[i]);
string lastDocumentSortable = GetSecondarySortString(documents[i - 1]);
Assert.IsTrue(String.Compare(lastDocumentSortable, thisDocumentSortable, StringComparison.Ordinal) >= 0);
}
}
public void CaseSensitiveNonMandatoryTerm()
{
BooleanQuery originalQuery = new BooleanQuery();
Term term = new Term("_name", "Value");
TermQuery termQuery = new TermQuery(term);
originalQuery.Add(termQuery, Occur.SHOULD);
string queryString = originalQuery.ToString();
QueryBuilder builder = new QueryBuilder();
builder.Setup(x => x.Term("_name", "Value", Matches.Sometimes, caseSensitive: true));
Query replacementQuery = builder.Build();
string newQueryString = replacementQuery.ToString();
Assert.AreEqual(queryString, newQueryString);
Console.Write(queryString);
}
public void Paging(LuceneSearch luceneSearch)
{
IQueryBuilder queryBuilder = new QueryBuilder();
queryBuilder.Setup(x => x.WildCard(BBCFields.Description, "a*"));
var results = ExecuteAndAssertPaged(luceneSearch, queryBuilder, 902, 0, 10);
var documents = results.GetPagedDocuments(0, 9);
Assert.AreEqual(10, documents.Count);
var results2 = ExecuteAndAssertPaged(luceneSearch, queryBuilder, 902, 1, 11);
var documents2 = results2.GetPagedDocuments(1, 10);
Assert.AreEqual(10, documents2.Count);
for (var i = 0; i < documents.Count - 1; i++)
{
Assert.AreEqual(documents2[i].GetValues(BBCFields.Title).FirstOrDefault(), documents[i+1].GetValues(BBCFields.Title).FirstOrDefault());
}
}
public void LongRange()
{
BooleanQuery originalQuery = new BooleanQuery();
NumericRangeQuery<long> numericRangeQuery = NumericRangeQuery.NewLongRange("field", 1, 0L, 10L, true, true);
originalQuery.Add(numericRangeQuery, Occur.MUST);
string queryString = originalQuery.ToString();
QueryBuilder builder = new QueryBuilder();
builder.Setup(x => x.NumericRange("field", 0L, 10L));
Query replacementQuery = builder.Build();
string newQueryString = replacementQuery.ToString();
Assert.AreEqual(queryString, newQueryString);
Console.Write(queryString);
}
public void SetupSyntax(LuceneSearch luceneSearch)
{
IQueryBuilder queryBuilder = new QueryBuilder();
queryBuilder.Setup(x => x.Term(BBCFields.Title, "africa"));
ExecuteAndAssert(luceneSearch, queryBuilder, 8);
}
public void QueryCaseSensitiveMandatoryWildCard()
{
BooleanQuery originalQuery = new BooleanQuery();
Term term = new Term("_name", "Value*");
WildcardQuery wildcardQuery = new WildcardQuery(term);
originalQuery.Add(wildcardQuery, Occur.MUST);
string queryString = originalQuery.ToString();
QueryBuilder builder = new QueryBuilder{CaseSensitive = true};
builder.Setup(x => x.WildCard("_name", "Value*"));
Query replacementQuery = builder.Build();
string newQueryString = replacementQuery.ToString();
Assert.AreEqual(queryString, newQueryString);
Console.Write(queryString);
}
public void Sorting(LuceneSearch luceneSearch)
{
IQueryBuilder queryBuilder = new QueryBuilder();
queryBuilder.Setup
(
x => x.WildCard(BBCFields.Description, "a*"),
x => x.Sort(BBCFields.Sortable)
);
ILuceneSearchResult result = ExecuteAndAssert(luceneSearch, queryBuilder, 902);
List<Document> documents = result.GetPagedDocuments(0, 100);
for (var i = 1; i < documents.Count; i++)
{
string thisDocumentSortable = documents[i].GetValues(BBCFields.Sortable).FirstOrDefault();
string lastDocumentSortable = documents[i - 1].GetValues(BBCFields.Sortable).FirstOrDefault();
Assert.IsTrue(String.Compare(thisDocumentSortable, lastDocumentSortable, StringComparison.Ordinal) >= 0);
}
}
public void SetupConstructorTest()
{
QueryBuilder setupBuilder = new QueryBuilder();
setupBuilder.Setup(x => x.Term("_name", "Value"));
Query setupQuery = setupBuilder.Build();
string setupQueryString = setupQuery.ToString();
QueryBuilder constructorBuilder = new QueryBuilder(x => x.Term("_name", "Value"));
Query constructorQuery = constructorBuilder.Build();
string constructorQueryString = constructorQuery.ToString();
Assert.AreEqual(setupQueryString, constructorQueryString);
}
public void SpeedExampleExecute(LuceneSearch luceneSearch, string startingCharacter)
{
// Chosen due to it being the slowest query
IQueryBuilder queryBuilder = new QueryBuilder();
queryBuilder.Setup
(
x => x.WildCard(BBCFields.Description, startingCharacter + "*"),
x => x.Term(BBCFields.Description, "sport")
);
var result = luceneSearch.Execute(queryBuilder);
Console.WriteLine("Total Results: {0}", result.TotalHits);
Console.WriteLine("Elapsed Time: {0}", result.ElapsedTimeMs);
}
public void BoostedCaseInsensitivePhrase()
{
BooleanQuery originalQuery = new BooleanQuery();
Term term = new Term("_name", "value");
PhraseQuery phraseQuery = new PhraseQuery();
phraseQuery.Slop = 2;
phraseQuery.Add(term);
phraseQuery.Boost = 10;
originalQuery.Add(phraseQuery, Occur.MUST);
string queryString = originalQuery.ToString();
QueryBuilder builder = new QueryBuilder();
builder.Setup(x => x.Phrase(2, 10).AddTerm("_name", "Value"));
Query replacementQuery = builder.Build();
string newQueryString = replacementQuery.ToString();
Assert.AreEqual(queryString, newQueryString);
Console.Write(queryString);
}
public void MoreResultsThanLuceneHits()
{
ID templateId = new ID(Constants.TestTemplateId);
QueryBuilder queryBuilder = new QueryBuilder();
queryBuilder.Setup(x => x.TemplateId(templateId));
// queryBuilder.TemplateId(templateId);
ISitecoreSearchResult sitecoreSearchResult = search.Execute(queryBuilder, 20);
Assert.Greater(sitecoreSearchResult.LuceneSearchResult.TotalHits, 0);
ISitecoreItemResult sitecoreItemResult = sitecoreSearchResult.GetPagedItems(0, 20);
Console.WriteLine("Lucene Elapsed Time: {0}", sitecoreSearchResult.ElapsedTimeMs);
Console.WriteLine("Sitecore Elapsed Time: {0}", sitecoreItemResult.ElapsedTimeMs);
Assert.AreEqual(2, sitecoreItemResult.Items.Count);
sitecoreItemResult.Items.ForEach(
item =>
{
Console.WriteLine(item.Name);
});
Assert.Greater(sitecoreItemResult.Items.Count, 0);
}
