public void ParseFilters_Filters_MapsCorrectly(string filterName)
{
// Arrange
var searchPhraseParseResult = new SearchPhraseParseResult
{
Filters = new List <IFilter>
{
base.GetFilterByName(filterName)
}
};
_phraseParserMock
.Setup(x => x.Parse(It.IsAny <string>()))
.Returns(searchPhraseParseResult);
// Act
var result = _indexSearchRequestBuilder
.ParseFilters(_phraseParserMock.Object, _fixture.Create <string>())
.Build();
// Assert
var filters = result.Filter.As <AndFilter>().ChildFilters;
base.AssertFiltersContainFilterByTypeName(filters, filterName);
}
public void ParseFilters_TermFilterWithoutWildCards_MapsCorrectly()
{
// Arrange
var termFilter = _fixture.Create <TermFilter>();
var searchPhraseParseResult = new SearchPhraseParseResult
{
Filters = new List <IFilter>
{
termFilter
}
};
_phraseParserMock
.Setup(x => x.Parse(It.IsAny <string>()))
.Returns(searchPhraseParseResult);
// Act
var result = _indexSearchRequestBuilder
.ParseFilters(_phraseParserMock.Object, _fixture.Create <string>())
.Build();
// Assert
var filters = result.Filter.As <AndFilter>().ChildFilters;
filters.Should().ContainEquivalentOf(termFilter);
}
public void ParseFilters_TermFilterWildCards_MapsCorrectly(string wildcard)
{
// Arrange
var termFilter = _fixture.Create <TermFilter>();
termFilter.Values.Add(wildcard);
var searchPhraseParseResult = new SearchPhraseParseResult
{
Filters = new List <IFilter>
{
termFilter
},
};
_phraseParserMock
.Setup(x => x.Parse(It.IsAny <string>()))
.Returns(searchPhraseParseResult);
// Act
var result = _indexSearchRequestBuilder
.ParseFilters(_phraseParserMock.Object, _fixture.Create <string>())
.Build();
// Assert
var filters = result.Filter.As <AndFilter>().ChildFilters;
filters.Should().ContainEquivalentOf(new OrFilter
{
ChildFilters = new List <IFilter>
{
new WildCardTermFilter
{
FieldName = termFilter.FieldName,
Value = wildcard
},
new TermFilter
{
Values = termFilter.Values.Where(x => !x.Contains(wildcard)).ToList(),
FieldName = termFilter.FieldName
}
}
});
}
public virtual SearchPhraseParseResult Parse(string input)
{
var stream = CharStreams.fromstring(input);
var lexer = new SearchPhraseLexer(stream);
var tokens = new CommonTokenStream(lexer);
var parser = new Antlr.SearchPhraseParser(tokens)
{
BuildParseTree = true
};
var listener = new SearchPhraseListener();
ParseTreeWalker.Default.Walk(listener, parser.searchPhrase());
var result = new SearchPhraseParseResult
{
Keyword = string.Join(" ", listener.Keywords),
Filters = listener.Filters,
};
return(result);
}
public void ParseFacets_FacetPhraseNotNull_MappingCorrect()
{
// Arrange
var idsFilter = _fixture.Create <IdsFilter>();
var rangeFilter = _fixture.Create <RangeFilter>();
var termFilter = _fixture.Create <TermFilter>();
var searchPhrase = _fixture.Create <string>();
var keywords = _fixture.CreateMany <string>();
var searchPhraseParseResult = new SearchPhraseParseResult
{
Filters = new List <IFilter>
{
idsFilter,
rangeFilter,
termFilter
},
Keyword = string.Join(" ", keywords)
};
_phraseParserMock
.Setup(x => x.Parse(It.IsAny <string>()))
.Returns(searchPhraseParseResult);
// Act
var actual = _indexSearchRequestBuilder
.ParseFacets(_phraseParserMock.Object, searchPhrase)
.Build();
// Assert
actual.Aggregations.Should().ContainEquivalentOf(new RangeAggregationRequest
{
Id = rangeFilter.As <IFilter>().Stringify(),
FieldName = rangeFilter.FieldName,
Values = rangeFilter.Values.Select(x => new RangeAggregationRequestValue
{
Id = x.Stringify(),
Lower = x.Lower,
Upper = x.Upper,
IncludeLower = x.IncludeLower,
IncludeUpper = x.IncludeUpper
}).ToList()
}, config => config.Excluding(x => x.Filter));
foreach (var fieldName in keywords)
{
var filter = new TermFilter
{
FieldName = fieldName,
Values = new List <string>()
};
actual.Aggregations.Should().ContainEquivalentOf(new TermAggregationRequest
{
Id = filter.As <IFilter>().Stringify(),
FieldName = filter.FieldName,
Filter = filter
});
}
actual.Aggregations.Should().ContainEquivalentOf(new TermAggregationRequest
{
Id = termFilter.As <IFilter>().Stringify(),
FieldName = termFilter.FieldName,
Filter = termFilter
});
actual.Aggregations.Count.Should().Be(
searchPhraseParseResult.Filters.OfType <RangeFilter>().Count()
+ searchPhraseParseResult.Filters.OfType <TermFilter>().Count());
}
