public async Task ApplyWhereClause_FilterByGenderRestriction_ReturnsCorrectPredicate()
{
const Gender filteredGenderRestriction = Gender.Female;
var mockManager = new QueryMockManager();
var expectedPredicate = new CompositePredicate(
new List <IPredicate>
{
new CompositePredicate(
new List <IPredicate>
{
new SimplePredicate(nameof(Post.GenderRestriction), ValueComparingOperator.Equal, filteredGenderRestriction),
new SimplePredicate(nameof(Post.GenderRestriction), ValueComparingOperator.Equal, Gender.NoInformation)
}, LogicalOperator.OR)
}, LogicalOperator.AND);
var mapperMock = mockManager.ConfigureMapperMock <Post, PostDto, PostFilterDto>();
var queryMock = mockManager.ConfigureQueryMock <Post>();
var postQueryObject = new PostQueryObject(mapperMock.Object, queryMock.Object);
var filter = new PostFilterDto {
GenderRestriction = filteredGenderRestriction
};
var temp = await postQueryObject.ExecuteQuery(filter);
Assert.AreEqual(expectedPredicate, mockManager.CapturedPredicate);
}
public async Task ApplyWhereClause_FilterByUserAge_ReturnsCorrectPredicate()
{
const int filteredUserAge = 30;
var mockManager = new QueryMockManager();
var agePredicates = new List <IPredicate>
{
new SimplePredicate(nameof(Post.HasAgeRestriction), ValueComparingOperator.Equal, false)
};
var innerAgePredicates = new List <IPredicate>
{
new SimplePredicate(nameof(Post.AgeRestrictionTo), ValueComparingOperator.LessThanOrEqual, filteredUserAge),
new SimplePredicate(nameof(Post.AgeRestrictionFrom), ValueComparingOperator.GreaterThanOrEqual, filteredUserAge)
};
agePredicates.Add(new CompositePredicate(innerAgePredicates, LogicalOperator.AND));
var expectedPredicate = new CompositePredicate(
new List <IPredicate>
{
new CompositePredicate(agePredicates, LogicalOperator.OR)
}, LogicalOperator.AND);
var mapperMock = mockManager.ConfigureMapperMock <Post, PostDto, PostFilterDto>();
var queryMock = mockManager.ConfigureQueryMock <Post>();
var postQueryObject = new PostQueryObject(mapperMock.Object, queryMock.Object);
var filter = new PostFilterDto {
UserAge = filteredUserAge
};
var temp = await postQueryObject.ExecuteQuery(filter);
Assert.AreEqual(expectedPredicate, mockManager.CapturedPredicate);
}
public async Task ApplyWhereClause_SimpleFilterWithMinimalPrice_ReturnsCorrectSimplePredicate()
{
var mockManager = new QueryMockManager();
var expectedPredicate = new SimplePredicate(nameof(Song.Price), ValueComparingOperator.GreaterThanOrEqual, 1000m);
var mapperMock = mockManager.ConfigureMapperMock <Song, ProductDto, ProductFilterDto>();
var queryMock = mockManager.ConfigureQueryMock <Song>();
var productQueryObject = new ProductQueryObject(mapperMock.Object, queryMock.Object);
var unused = await productQueryObject.ExecuteQuery(new ProductFilterDto { MinimalPrice = 1000 });
Assert.AreEqual(mockManager.CapturedPredicate, expectedPredicate);
}
public async Task ApplyWhereClause_ComplexFilterByAllParameters_ReturnsCorrectPredicate()
{
const int filteredUserAge = 30;
Gender filteredGenderRestriction = Gender.Female;
PostVisibility filteredPostVisibility = PostVisibility.FriendsOnly;
Guid filteredUserId = Guid.NewGuid();
var mockManager = new QueryMockManager();
var agePredicates = new List <IPredicate>
{
new SimplePredicate(nameof(Post.HasAgeRestriction), ValueComparingOperator.Equal, false)
};
var innerAgePredicates = new List <IPredicate>
{
new SimplePredicate(nameof(Post.AgeRestrictionTo), ValueComparingOperator.LessThanOrEqual, filteredUserAge),
new SimplePredicate(nameof(Post.AgeRestrictionFrom), ValueComparingOperator.GreaterThanOrEqual, filteredUserAge)
};
agePredicates.Add(new CompositePredicate(innerAgePredicates, LogicalOperator.AND));
var genderPredicate = new CompositePredicate(
new List <IPredicate>
{
new SimplePredicate(nameof(Post.GenderRestriction), ValueComparingOperator.Equal, filteredGenderRestriction),
new SimplePredicate(nameof(Post.GenderRestriction), ValueComparingOperator.Equal, Gender.NoInformation)
}, LogicalOperator.OR);
var userIdPredicate = new SimplePredicate(nameof(Post.UserId), ValueComparingOperator.Equal, filteredUserId);
var visibilityPredicate = new SimplePredicate(nameof(Post.Visibility), ValueComparingOperator.Equal, filteredPostVisibility);
var expectedPredicate = new CompositePredicate(
new List <IPredicate>
{
new CompositePredicate(agePredicates, LogicalOperator.OR),
genderPredicate,
userIdPredicate,
visibilityPredicate
}, LogicalOperator.AND);
var mapperMock = mockManager.ConfigureMapperMock <Post, PostDto, PostFilterDto>();
var queryMock = mockManager.ConfigureQueryMock <Post>();
var postQueryObject = new PostQueryObject(mapperMock.Object, queryMock.Object);
var filter = new PostFilterDto
{
UserAge = filteredUserAge,
GenderRestriction = filteredGenderRestriction,
UserId = filteredUserId
};
var temp = await postQueryObject.ExecuteQuery(filter);
Assert.AreEqual(expectedPredicate, mockManager.CapturedPredicate);
}
public async Task ExecuteUserQuery()
{
var mockManager = new QueryMockManager();
var expectedPredicate = new SimplePredicate(nameof(User.NickName), ValueComparingOperator.StringContains, "Misko");
var mapperMock = mockManager.ConfigureMapperMock <User, UserDto, UserFilterDto>();
var queryMock = mockManager.ConfigureQueryMock <User>();
var productQueryObject = new UserQueryObject(mapperMock.Object, queryMock.Object);
var unused = await productQueryObject.ExecuteQuery(new UserFilterDto { SubName = "Misko" });
Assert.AreEqual(mockManager.CapturedPredicate, expectedPredicate);
}
public async Task ApplyWhereClause_EmptyFilter_ReturnsNull()
{
var mockManager = new QueryMockManager();
var mapperMock = mockManager.ConfigureMapperMock <Friendship, FriendshipDto, FriendshipFilterDto>();
var queryMock = mockManager.ConfigureQueryMock <Friendship>();
var friendshipQueryObject = new FriendshipQueryObject(mapperMock.Object, queryMock.Object);
var filter = new FriendshipFilterDto();
var temp = await friendshipQueryObject.ExecuteQuery(filter);
Assert.AreEqual(null, mockManager.CapturedPredicate);
}
public async Task ApplyWhereClause_EmptyFilter_ReturnsNull()
{
var mockManager = new QueryMockManager();
var mapperMock = mockManager.ConfigureMapperMock <Hashtag, HashtagDto, HashtagFilterDto>();
var queryMock = mockManager.ConfigureQueryMock <Hashtag>();
var hashtagQueryObject = new HashtagQueryObject(mapperMock.Object, queryMock.Object);
var filter = new HashtagFilterDto();
var temp = await hashtagQueryObject.ExecuteQuery(filter);
Assert.AreEqual(null, mockManager.CapturedPredicate);
}
public async Task ApplyWhereClause_SimpleFilterWithSpecialization_ReturnsCorrectSimplePredicate()
{
var mockManager = new QueryMockManager();
var expectedPredicate = new SimplePredicate(nameof(Doctor.Specialization), ValueComparingOperator.Equal, Specialization.Ophthalmologist);
var mapperMock = mockManager.ConfigureMapperMock <Doctor, DoctorDto, DoctorFilterDto>();
var queryMock = mockManager.ConfigureQueryMock <Doctor>();
var doctorQueryObject = new DoctorQueryObject(mapperMock.Object, queryMock.Object);
var unused = await doctorQueryObject.ExecuteQuery(new DoctorFilterDto { Specialization = "Ophthalmologist" });
Assert.AreEqual(mockManager.CapturedPredicate, expectedPredicate);
}
public async Task ApplyWhereClause_SimpleFilterWithName_ReturnsCorrectSimplePredicate()
{
var mockManager = new QueryMockManager();
var expectedPredicate = new SimplePredicate(nameof(Disease.Name), ValueComparingOperator.StringContains, "Death");
var mapperMock = mockManager.ConfigureMapperMock <Disease, DiseaseDto, DiseaseFilterDto>();
var queryMock = mockManager.ConfigureQueryMock <Disease>();
var diseaseQueryObject = new DiseaseQueryObject(mapperMock.Object, queryMock.Object);
var unused = await diseaseQueryObject.ExecuteQuery(new DiseaseFilterDto { DiseaseName = "Death" });
Assert.AreEqual(mockManager.CapturedPredicate, expectedPredicate);
}
public async Task ApplyWhereClause_SimpleFilterWithIdentificationNumber_ReturnsCorrectSimplePredicate()
{
var mockManager = new QueryMockManager();
var expectedPredicate = new SimplePredicate(nameof(Patient.IdentificationNumber), ValueComparingOperator.Equal, "999999");
var mapperMock = mockManager.ConfigureMapperMock <Patient, PatientDto, PatientFilterDto>();
var queryMock = mockManager.ConfigureQueryMock <Patient>();
var patientQueryObject = new PatientQueryObject(mapperMock.Object, queryMock.Object);
var unused = await patientQueryObject.ExecuteQuery(new PatientFilterDto { IdentificationNumber = "999999" });
Assert.AreEqual(mockManager.CapturedPredicate, expectedPredicate);
}
public async Task ApplyWhereClause_FilterByUsername_ReturnsCorrectSimplePredicate()
{
Guid filteredPostId = Guid.NewGuid();
var mockManager = new QueryMockManager();
var expectedPredicate = new SimplePredicate(nameof(PostReply.PostId), ValueComparingOperator.Equal, filteredPostId);
var mapperMock = mockManager.ConfigureMapperMock <PostReply, PostReplyDto, PostReplyFilterDto>();
var queryMock = mockManager.ConfigureQueryMock <PostReply>();
var postReplyQueryObject = new PostReplyQueryObject(mapperMock.Object, queryMock.Object);
var filter = new PostReplyFilterDto {
PostId = filteredPostId
};
var temp = await postReplyQueryObject.ExecuteQuery(filter);
Assert.AreEqual(expectedPredicate, mockManager.CapturedPredicate);
}
public async Task ApplyWhereClause_FilterByImageId_ReturnsCorrectSimplePredicate()
{
Guid filterImageId = Guid.NewGuid();
var mockManager = new QueryMockManager();
var expectedPredicate = new SimplePredicate(nameof(Vote.ImageId), ValueComparingOperator.Equal, filterImageId);
var mapperMock = mockManager.ConfigureMapperMock <Vote, VoteDto, VoteFilterDto>();
var queryMock = mockManager.ConfigureQueryMock <Vote>();
var voteQueryObject = new VoteQueryObject(mapperMock.Object, queryMock.Object);
var filter = new VoteFilterDto {
ImageId = filterImageId
};
var temp = await voteQueryObject.ExecuteQuery(filter);
Assert.AreEqual(expectedPredicate, mockManager.CapturedPredicate);
}
public async Task ApplyWhereClause_SimpleFilterWithName_ReturnsCorrectCompositePredicate()
{
var mockManager = new QueryMockManager();
var predicateList = new List <IPredicate> {
new SimplePredicate(nameof(Doctor.Name), ValueComparingOperator.Equal, "John"),
new SimplePredicate(nameof(Doctor.Surname), ValueComparingOperator.Equal, "Doe")
};
var expectedPredicate = new CompositePredicate(predicateList);
var mapperMock = mockManager.ConfigureMapperMock <Doctor, DoctorDto, DoctorFilterDto>();
var queryMock = mockManager.ConfigureQueryMock <Doctor>();
var doctorQueryObject = new DoctorQueryObject(mapperMock.Object, queryMock.Object);
var unused = await doctorQueryObject.ExecuteQuery(new DoctorFilterDto { FullName = "John Doe" });
Assert.AreEqual(mockManager.CapturedPredicate, expectedPredicate);
}
public async Task ApplyWhereClause_SimpleFilterWithName_ReturnsCorrectCompositePredicate()
{
var mockManager = new QueryMockManager();
var predicateList = new List <IPredicate> {
new SimplePredicate(nameof(Patient.Name), ValueComparingOperator.Equal, "Harry"),
new SimplePredicate(nameof(Patient.Surname), ValueComparingOperator.Equal, "Maybourne")
};
var expectedPredicate = new CompositePredicate(predicateList);
var mapperMock = mockManager.ConfigureMapperMock <Patient, PatientDto, PatientFilterDto>();
var queryMock = mockManager.ConfigureQueryMock <Patient>();
var patientQueryObject = new PatientQueryObject(mapperMock.Object, queryMock.Object);
var unused = await patientQueryObject.ExecuteQuery(new PatientFilterDto { FullName = "Harry Maybourne" });
Assert.AreEqual(mockManager.CapturedPredicate, expectedPredicate);
}
public async Task ApplyWhereClause_ComplexFilterWithMinimalPriceAndCategoryId_ReturnsCorrectCompositePredicate()
{
var categoryIds = new[] { Guid.Parse("aa02dc64-5c07-40fe-a916-175165b9b90f") };
var mockManager = new QueryMockManager();
var expectedPredicate = new CompositePredicate(new List <IPredicate> {
new CompositePredicate(new List <IPredicate> {
new SimplePredicate(nameof(Song.CategoryId), ValueComparingOperator.Equal, categoryIds.First())
}, LogicalOperator.OR),
new SimplePredicate(nameof(Song.Price), ValueComparingOperator.GreaterThanOrEqual, 7000m)
});
var mapperMock = mockManager.ConfigureMapperMock <Song, ProductDto, ProductFilterDto>();
var queryMock = mockManager.ConfigureQueryMock <Song>();
var productQueryObject = new ProductQueryObject(mapperMock.Object, queryMock.Object);
var unused = await productQueryObject.ExecuteQuery(new ProductFilterDto { MinimalPrice = 7000, CategoryIds = categoryIds });
Assert.AreEqual(mockManager.CapturedPredicate, expectedPredicate);
}
public async Task ApplyWhereClause_SimpleFilterWithMinimalPrice_ReturnsCorrectSimplePredicate()
{
const string desiredName1 = "Android";
const string desiredName2 = "iOS";
var mockManager = new QueryMockManager();
var expectedPredicate = new CompositePredicate(
new List <IPredicate>
{
new SimplePredicate(nameof(Album.Name), ValueComparingOperator.Equal, desiredName1),
new SimplePredicate(nameof(Album.Name), ValueComparingOperator.Equal, desiredName2)
}, LogicalOperator.OR);
var mapperMock = mockManager.ConfigureMapperMock <Album, CategoryDto, CategoryFilterDto>();
var queryMock = mockManager.ConfigureQueryMock <Album>();
var categoryQueryObject = new CategoryQueryObject(mapperMock.Object, queryMock.Object);
var unused = await categoryQueryObject.ExecuteQuery(new CategoryFilterDto { Names = new [] { desiredName1, desiredName2 } });
Assert.AreEqual(mockManager.CapturedPredicate, expectedPredicate);
}
public async Task ApplyWhereClause_FilterByVisibility_ReturnsCorrectPredicate()
{
const PostVisibility filteredVisibility = PostVisibility.FriendsOnly;
var mockManager = new QueryMockManager();
var expectedPredicate = new CompositePredicate(
new List <IPredicate>
{
new SimplePredicate(nameof(Post.Visibility), ValueComparingOperator.Equal, filteredVisibility)
}, LogicalOperator.AND);
var mapperMock = mockManager.ConfigureMapperMock <Post, PostDto, PostFilterDto>();
var queryMock = mockManager.ConfigureQueryMock <Post>();
var postQueryObject = new PostQueryObject(mapperMock.Object, queryMock.Object);
var filter = new PostFilterDto {
};
var temp = await postQueryObject.ExecuteQuery(filter);
Assert.AreEqual(expectedPredicate, mockManager.CapturedPredicate);
}
public async Task ApplyWhereClause_FilterByTagString_ReturnsCorrectPredicate()
{
const string filteredTag = "Hashtag";
var mockManager = new QueryMockManager();
var expectedPredicate = new CompositePredicate(new List <IPredicate>
{
new SimplePredicate(nameof(Hashtag.Tag), ValueComparingOperator.Equal, filteredTag)
}, LogicalOperator.AND);
var mapperMock = mockManager.ConfigureMapperMock <Hashtag, HashtagDto, HashtagFilterDto>();
var queryMock = mockManager.ConfigureQueryMock <Hashtag>();
var hashtagQueryObject = new HashtagQueryObject(mapperMock.Object, queryMock.Object);
var filter = new HashtagFilterDto {
Tag = filteredTag
};
var temp = await hashtagQueryObject.ExecuteQuery(filter);
Assert.AreEqual(expectedPredicate, mockManager.CapturedPredicate);
}
public async Task ApplyWhereClause_FilterByUserBId_ReturnsCorrectPredicate()
{
Guid filteredUserId = Guid.NewGuid();
var mockManager = new QueryMockManager();
var expectedPredicate = new CompositePredicate(new List <IPredicate>
{
new SimplePredicate(nameof(Friendship.ApplicantId), ValueComparingOperator.Equal, filteredUserId),
new SimplePredicate(nameof(Friendship.RecipientId), ValueComparingOperator.Equal, filteredUserId)
}, LogicalOperator.OR);
var mapperMock = mockManager.ConfigureMapperMock <Friendship, FriendshipDto, FriendshipFilterDto>();
var queryMock = mockManager.ConfigureQueryMock <Friendship>();
var friendshipQueryObject = new FriendshipQueryObject(mapperMock.Object, queryMock.Object);
var filter = new FriendshipFilterDto {
UserB = filteredUserId
};
var temp = await friendshipQueryObject.ExecuteQuery(filter);
Assert.AreEqual(expectedPredicate, mockManager.CapturedPredicate);
}
public async Task ApplyWhereClause_SimpleFilterByEmail_ReturnsCorrectPredicate()
{
const string filteredEmail = "*****@*****.**";
var mockManager = new QueryMockManager();
var expectedPredicate = new CompositePredicate(
new List <IPredicate>
{
new SimplePredicate(nameof(User.Email), ValueComparingOperator.Equal, filteredEmail)
}, LogicalOperator.AND);
var mapperMock = mockManager.ConfigureMapperMock <User, UserDto, UserFilterDto>();
var queryMock = mockManager.ConfigureQueryMock <User>();
var userQueryObject = new UserQueryObject(mapperMock.Object, queryMock.Object);
var filter = new UserFilterDto {
Email = filteredEmail
};
var temp = await userQueryObject.ExecuteQuery(filter);
Assert.AreEqual(expectedPredicate, mockManager.CapturedPredicate);
}
public async Task ApplyWhereClause_SimpleFilterByBornBefore_ReturnsCorrectPredicate()
{
DateTime filterBornBefore = new DateTime(2018, 12, 12);
var mockManager = new QueryMockManager();
var expectedPredicate = new CompositePredicate(
new List <IPredicate>
{
new SimplePredicate(nameof(User.Birthdate), ValueComparingOperator.LessThan, filterBornBefore)
}, LogicalOperator.AND);
var mapperMock = mockManager.ConfigureMapperMock <User, UserDto, UserFilterDto>();
var queryMock = mockManager.ConfigureQueryMock <User>();
var userQueryObject = new UserQueryObject(mapperMock.Object, queryMock.Object);
var filter = new UserFilterDto {
BornBefore = filterBornBefore
};
var temp = await userQueryObject.ExecuteQuery(filter);
Assert.AreEqual(expectedPredicate, mockManager.CapturedPredicate);
}
public async Task ApplyWhereClause_FilterByUserId_ReturnsCorrectPredicate()
{
Guid filteredUserId = Guid.NewGuid();
var mockManager = new QueryMockManager();
var expectedPredicate = new CompositePredicate(
new List <IPredicate>
{
new SimplePredicate(nameof(Post.UserId), ValueComparingOperator.Equal, filteredUserId)
}, LogicalOperator.AND);
var mapperMock = mockManager.ConfigureMapperMock <Post, PostDto, PostFilterDto>();
var queryMock = mockManager.ConfigureQueryMock <Post>();
var postQueryObject = new PostQueryObject(mapperMock.Object, queryMock.Object);
var filter = new PostFilterDto {
UserId = filteredUserId
};
var temp = await postQueryObject.ExecuteQuery(filter);
Assert.AreEqual(expectedPredicate, mockManager.CapturedPredicate);
}
public async Task ApplyWhereClause_ComplexFilterWithSeveralConditions_ReturnsCorrectCompositePredicate()
{
const string searchedName = "Samsung";
var categoryIds = new[] { Guid.Parse("aa02dc64-5c07-40fe-a916-175165b9b90f"), Guid.Parse("aa04dc64-5c07-40fe-a916-175165b9b90f") };
var mockManager = new QueryMockManager();
var expectedPredicate = new CompositePredicate(new List <IPredicate> {
new CompositePredicate(new List <IPredicate> {
new SimplePredicate(nameof(Song.CategoryId), ValueComparingOperator.Equal, categoryIds.First()),
new SimplePredicate(nameof(Song.CategoryId), ValueComparingOperator.Equal, categoryIds.Last())
}, LogicalOperator.OR),
new SimplePredicate(nameof(Song.Name), ValueComparingOperator.StringContains, searchedName),
new CompositePredicate(new List <IPredicate> {
new SimplePredicate(nameof(Song.Price), ValueComparingOperator.GreaterThanOrEqual, 1000m),
new SimplePredicate(nameof(Song.Price), ValueComparingOperator.LessThanOrEqual, 3000m)
})
});
var mapperMock = mockManager.ConfigureMapperMock <Song, ProductDto, ProductFilterDto>();
var queryMock = mockManager.ConfigureQueryMock <Song>();
var productQueryObject = new ProductQueryObject(mapperMock.Object, queryMock.Object);
var unused = await productQueryObject.ExecuteQuery(new ProductFilterDto { MinimalPrice = 1000, MaximalPrice = 3000, SearchedName = searchedName, CategoryIds = categoryIds });
Assert.AreEqual(mockManager.CapturedPredicate, expectedPredicate);
}
