public void ShouldGetQueryFromAPredicate()
{
// Arrange
var testAlbum = "test album";
var testArtist = "test artist";
var testTrack = "test track";
var testUpc = "test upc";
var year1 = 2000;
var year2 = 17;
var hipster = Tag.Hipster;
// Act
var query = QueryProvider.Get <QueryFields>(f =>
f.Any.Contains("rock") &&
f.Album == testAlbum &&
((testAlbum == f.Album &&
testArtist == f.Artist &&
f.Track != testTrack ||
hipster != f.Tag ||
f.Tag == Tag.New ||
"test genre" != f.Genre &&
!f.Upc.Contains(testUpc) &&
f.Isrc == "test isrc") &&
f.Year == 2015 &&
(f.Year >= (year1 + year2) &&
f.Year <= 2019) &&
!(2020 >= f.Year &&
f.Year >= 2018)));
// Assert
query.Should().Be("rock album:\"test album\" album:\"test album\" artist:\"test artist\" NOT track:\"test track\" OR NOT tag:hipster OR tag:new OR NOT genre:\"test genre\" NOT upc:test upc isrc:\"test isrc\" year:2015 year:2017-2019 NOT year:2018-2020");
}
public void ShouldThrowArgumentExceptionWhenUnaryOperandIsNotSupported()
{
// Arrange + Act + Assert
((Action)(() => QueryProvider.Get <QueryFields>(f => !(f.Album == "test album" && f.Artist == "test artist"))))
.ShouldThrow <ArgumentException>()
.Which.Message.Should().Match("Unsupported NOT expression operand of type '*' has been found.");
}
public void ShouldThrowArgumentExceptionWhenRangeIsNotValid()
{
// Arrange + Act + Assert
((Action)(() => QueryProvider.Get <QueryFields>(f => f.Album == "test album" && f.Year >= 2015)))
.ShouldThrow <ArgumentException>()
.Which.Message.Should().Be("Range must be the following sequence: BinaryExpression, ExpressionType, BinaryExpression.");
((Action)(() => QueryProvider.Get <QueryFields>(f => f.Album == "test album" && f.Year >= 2015 && f.Year < 2017)))
.ShouldThrow <ArgumentException>()
.Which.Message.Should().Be("Only bound expressions with 'GreaterThanOrEqual' or 'LessThanOrEqual' operators are supported.");
var value = 123;
((Action)(() => QueryProvider.Get <QueryFields>(f => f.Album == "test album" && value >= 2015 && f.Year <= 2017)))
.ShouldThrow <ArgumentException>()
.Which.Message.Should().Be("One of the bound expression operands must be a query field.");
((Action)(() => QueryProvider.Get <QueryFields>(f => f.Album == "test album" && (f.Year >= 2015 || f.Year <= 2017))))
.ShouldThrow <ArgumentException>()
.Which.Message.Should().Be("Only range expressions with 'AndAlso' operator are supported.");
((Action)(() => QueryProvider.Get <TestQueryFields>(f => f.Album == "test album" && f.TestValue >= 2015 && f.Year <= 2017)))
.ShouldThrow <ArgumentException>()
.Which.Message.Should().Be("Both range bound expressions must reference the same query field.");
((Action)(() => QueryProvider.Get <QueryFields>(f => f.Album == "test album" && f.Year >= 2015 && f.Year >= 2017)))
.ShouldThrow <ArgumentException>()
.Which.Message.Should().Be("Range bound expressions must define a range.");
}
public void ShouldThrowArgumentExceptionWhenContainsCallObjectIsNotAQueryField()
{
// Arrange + Act + Assert
((Action)(() => QueryProvider.Get <QueryFields>(f => "test".Contains("e"))))
.ShouldThrow <ArgumentException>()
.Which.Message.Should().Match("The Contains call object expression must be a query field.");
}
public void ShouldThrowArgumentExceptionWhenNoneOfTheEqualityOperandsIsAQueryField()
{
// Arrange + Act + Assert
((Action)(() => QueryProvider.Get <QueryFields>(f => f == null)))
.ShouldThrow <ArgumentException>()
.Which.Message.Should().Match("One of the equal expression operands must be a query field.");
}
public void ShouldThrowArgumentExceptionWhenExpressionTypeIsNotSupported()
{
// Arrange + Act + Assert
((Action)(() => QueryProvider.Get <QueryFields>(f => f.Album == "test album" | f.Artist == "test artist")))
.Should().Throw <ArgumentException>()
.Which.Message.Should().Match("*Unsupported expression of type '*' has been found.*");
}
public void ShouldGetQueryFromASingleStatementPredicate()
{
// Arrange + Act
var query = QueryProvider.Get <QueryFields>(f => f.Genre.Contains("rock"));
// Assert
query.Should().Be("genre:rock");
}
public void ShouldRemoveSpecialCharactersInPredicate()
{
// Arrange + Act
var query = QueryProvider.Get <QueryFields>(
f =>
f.Artist == "test \" artist" &&
f.Album.Contains("test \"\" album:album"),
new QueryOptions {
RemoveSpecialCharacters = true
});
// Assert
query.Should().Be("artist:\"test artist\" album:test albumalbum");
}
public void ShouldNormalizePartialMatchInPredicate()
{
// Arrange + Act
var query = QueryProvider.Get <QueryFields>(
f =>
f.Artist.Contains("part1 part2 part3") &&
!f.Album.Contains("me OR my") &&
f.Track.Contains(" ") &&
f.Any.Contains("any1 any2 any3"),
new QueryOptions {
NormalizePartialMatch = true
});
// Assert
query.Should().Be("artist:part1 artist:part2 artist:part3 NOT album:me NOT album:or NOT album:my track: any1 any2 any3");
}
public ISearchTypeQueryBuilder <T> Matching(Expression <Func <QueryFields, bool> > predicate, QueryOptions queryOptions)
{
return(new SearchTypeQueryBuilder <T>(this, this.entities, QueryProvider.Get(predicate, queryOptions)));
}
public ISearchTypeQueryBuilder <T> Matching(Expression <Func <QueryFields, bool> > predicate)
{
return(new SearchTypeQueryBuilder(this.searchBuilder, this.entities, QueryProvider.Get(predicate)));
}