public async Task GetDiseaseByNameAsync()
{
var diseaseId = Guid.Parse("00000000-0000-0000-0000-000000000001");
const string name = "tuberkulosis";
var diseaseDto = new DiseaseDto
{
Id = diseaseId,
Name = name
};
var expectedResult = new List <DiseaseDto> {
diseaseDto
};
var returnedResult = new QueryResultDto <DiseaseDto, DiseaseFilterDto>
{
Items = new List <DiseaseDto> {
diseaseDto
}
};
var mockManager = new FacadeMockManager();
var diseaseRepositoryMock = mockManager.ConfigureRepositoryMock <Disease>();
var diseaseQueryMock = mockManager.ConfigureQueryObjectMock <DiseaseDto, Disease, DiseaseFilterDto>(returnedResult);
var sympthomRepositoryMock = mockManager.ConfigureRepositoryMock <Sympthom>();
var sympthomQueryMock = mockManager.ConfigureQueryObjectMock <SympthomDto, Sympthom, SympthomFilterDto>(null);
var diseaseFacade = CreateDiseaseFacade(diseaseQueryMock, diseaseRepositoryMock, sympthomQueryMock, sympthomRepositoryMock);
var actualResult = await diseaseFacade.GetDiseaseByNameAsync("tuber");
Assert.AreEqual(actualResult, expectedResult);
}
public async Task CreateDiseaseAsync()
{
var diseaseId = Guid.Parse("00000000-0000-0000-0000-000000000002");
const string name = "tuberkulosis";
var returnedResult = new QueryResultDto <DiseaseDto, DiseaseFilterDto>
{
Items = new List <DiseaseDto> {
new DiseaseDto {
Id = diseaseId
}
}
};
var mockManager = new FacadeMockManager();
var diseaseRepositoryMock = mockManager.ConfigureCreateRepositoryMock <Disease>(nameof(Disease.Id));
var diseaseQueryMock = mockManager.ConfigureQueryObjectMock <DiseaseDto, Disease, DiseaseFilterDto>(returnedResult);
var sympthomRepositoryMock = mockManager.ConfigureRepositoryMock <Sympthom>();
var sympthomQueryMock = mockManager.ConfigureQueryObjectMock <SympthomDto, Sympthom, SympthomFilterDto>(null);
var diseaseFacade = CreateDiseaseFacade(diseaseQueryMock, diseaseRepositoryMock, sympthomQueryMock, sympthomRepositoryMock);
await diseaseFacade.CreateDiseaseAsync(new DiseaseDto { Id = diseaseId, Name = name });
Assert.AreEqual(diseaseId, mockManager.CapturedCreatedId);
}
public async Task GetUserAccordingToEmailAsync_ExistingUser_ReturnCorrectUser()
{
const string userEmail = "*****@*****.**";
var expectedUser = new UserDto
{
Id = Guid.NewGuid(),
Name = "Test User",
Email = userEmail,
Phone = "+420777123456"
};
var expectedQueryResult = new QueryResultDto <UserDto, UserFilterDto>
{
Items = new List <UserDto> {
expectedUser
}
};
var userFacade = CreateUserFacade(expectedQueryResult);
var actualUser = await userFacade.GetUserAccordingToEmailAsync("sad");
Assert.Equal(expectedUser, actualUser);
}
public async Task GetAllUsersPostsAsyncTest()
{
var expectedPosts = new List <PostDto>()
{
new PostDto()
{
UserId = 1,
Text = "Post1"
},
new PostDto()
{
UserId = 2,
Text = "Post2"
}
};
var expectedQueryResult = new QueryResultDto <PostDto, PostFilterDto> {
Items = expectedPosts
};
var postFacade = CreateUserFacade(expectedQueryResult);
var actualPosts = await postFacade.GetPostsByUserIdAsync(3); //diky generice dam 3 a stejne prochazi, fasada se vsak o toto nestara... :)
Assert.AreEqual(actualPosts, expectedPosts);
}
public async Task <QueryResultDto <Customer> > GetCustomers(CustomerQuery queryObj)
{
var result = new QueryResultDto <Customer>();
var query = context.Customers
.Include(x => x.Invoices)
.AsQueryable();
query = ApplyFiltering(queryObj, query);
var columnsMap = new Dictionary <string, Expression <Func <Customer, object> > >
{
["address"] = v => v.Address,
["customerId"] = v => v.CustomerId,
["firstName"] = v => v.FirstName,
["lastName"] = v => v.LastName
};
query = query.ApplyOrdering(queryObj, columnsMap);
result.TotalItems = await query.CountAsync();
query = query.ApplyPaging(queryObj);
result.Items = await query.ToListAsync();
return(result);
}
public async Task GetAllUsersAsync_ThreeExistingCustomer_ReturnCorrectList()
{
var expectedUsers = new List <UserDto>
{
new UserDto
{
Id = 1,
NickName = "Misko"
},
new UserDto
{
Id = 2,
NickName = "Misko2"
},
new UserDto
{
Id = 3,
NickName = "Marcello"
}
};
var expectedQueryResult = new QueryResultDto <UserDto, UserFilterDto> {
Items = expectedUsers
};
var mockManager = new FacadeMockManager();
var uowMock = FacadeMockManager.ConfigureUowMock();
var queryMock = mockManager.ConfigureQueryObjectMock <UserDto, User, UserFilterDto>(expectedQueryResult);
var userService = new UserService(null, null, queryMock.Object);
var crudService = new CrudQueryServiceBase <User, UserDto, UserFilterDto>(null, null, queryMock.Object);
var userFacade = new UserGenericFacade(uowMock.Object, crudService, userService);
var actualUsers = await userFacade.GetAllItemsAsync();
Assert.AreEqual(expectedUsers, actualUsers.Items);
}
private async Task <SongListViewModel> InitializeSongListViewModel(QueryResultDto <SongDto, SongFilterDto> result, int totalItemsCount, IList <AlbumDto> albums = null)
{
return(new SongListViewModel
{
Songs = new StaticPagedList <SongDto>(result.Items, result.RequestedPageNumber ?? 1, PageSize, totalItemsCount),
Albums = albums ?? await SongFacade.GetAllAlbums() as IList <AlbumDto>,
Filter = result.Filter
});
}
private FriendRequestListViewModel InitializeFriendRequestListViewModel(
QueryResultDto <FriendshipDto, FriendshipFilterDto> result)
{
return(new FriendRequestListViewModel
{
FriendRequests = new StaticPagedList <FriendshipDto>(result.Items, result.RequestedPageNumber ?? 1, FriendRequestsPageSize,
(int)result.TotalItemsCount),
Filter = result.Filter
});
}
ConfigureQueryObjectMock <TDto, TEntity, TFilterDto>(QueryResultDto <TDto, TFilterDto> result)
where TEntity : class, IEntity, new()
where TFilterDto : FilterDtoBase
{
var queryMock = new Mock <QueryObjectBase <TDto, TEntity, TFilterDto, IQuery <TEntity> > >(MockBehavior.Loose, null, null);
queryMock
.Setup(query => query.ExecuteQuery(It.IsAny <TFilterDto>()))
.ReturnsAsync(result);
return(queryMock);
}
public async Task GetProductsAsync_ExistingProduct_ReturnsCorrectCustomer()
{
const int storedAmount = 10;
const int reservedAmount = 3;
var firstProductId = Guid.NewGuid();
var secondProductId = Guid.NewGuid();
var returnedResult = new QueryResultDto <ProductDto, ProductFilterDto>
{
Filter = new ProductFilterDto(),
Items = new List <ProductDto> {
new ProductDto {
Id = firstProductId, StoredUnits = storedAmount
},
new ProductDto {
Id = secondProductId, StoredUnits = storedAmount
}
},
TotalItemsCount = 2
};
var productReservation = new ProductReservationDto
{
CustomerId = Guid.NewGuid(),
Expiration = DateTime.Now.Add(new TimeSpan(1, 0, 0)),
ProductId = firstProductId,
ReservedAmount = reservedAmount
};
var expectedResult = new List <ProductDto> {
new ProductDto {
Id = firstProductId, StoredUnits = storedAmount, CurrentlyAvailableUnits = storedAmount - reservedAmount
},
new ProductDto {
Id = secondProductId, StoredUnits = storedAmount, CurrentlyAvailableUnits = storedAmount
}
};
var mockManager = new FacadeMockManager();
var productRepositoryMock = mockManager.ConfigureRepositoryMock <Song>();
var categoryRepositoryMock = mockManager.ConfigureRepositoryMock <Album>();
var productQueryMock = mockManager.ConfigureQueryObjectMock <ProductDto, Song, ProductFilterDto>(returnedResult);
var categoryQueryMock = mockManager.ConfigureQueryObjectMock <CategoryDto, Album, CategoryFilterDto>(null);
var productFacade = await CreateProductFacade(productQueryMock, productRepositoryMock, categoryRepositoryMock, categoryQueryMock, productReservation);
productQueryMock.Setup(query => query.ExecuteQuery(It.IsAny <ProductFilterDto>())).ReturnsAsync(returnedResult);
productRepositoryMock.Setup(repo => repo.GetAsync(It.IsAny <Guid>()))
.ReturnsAsync(new Song {
StoredUnits = storedAmount
});
var actualResult = (await productFacade.GetProductsAsync(new ProductFilterDto())).Items;
Assert.AreEqual(expectedResult, actualResult);
}
private async Task <AuctionListViewModel> InitializeAuctionListViewModel(QueryResultDto <AuctionDTO, AuctionFilterDto> result, IEnumerable <AuctionDTO> filteredAuctions, int totalItemsCount)
{
return(new AuctionListViewModel
{
Auctions = new StaticPagedList <AuctionDTO>(filteredAuctions, result.RequestedPageNumber ?? 1, PageSize, totalItemsCount),
Filter = result.Filter,
CategoriesSelectList = new List <SelectListItem>((await AuctionFacade.GetAllCategories()).Select(x => new SelectListItem {
Text = x.Name, Value = x.Id.ToString()
}))
});
}
/// <summary>
/// Initializes new AuctionListViewModel according to its parameters
/// </summary>
/// <param name="result">Auction list query result containing auctions page and related data</param>
/// <param name="categories">List of category trees</param>
/// <returns>Initialized instance of AuctionListViewModel</returns>
private async Task <AuctionListViewModel> InitializeProductListViewModel(
QueryResultDto <AuctionDto, AuctionFilterDto> result, IList <CategoryDto> categories = null)
{
return(new AuctionListViewModel
{
Auctions = new StaticPagedList <AuctionDto>(result.Items, result.RequestedPageNumber ?? 1, PageSize,
(int)result.TotalItemsCount),
Categories = categories ?? await AuctionProcessFacade.GetAllCategoriesAsync() as IList <CategoryDto>,
Filter = result.Filter
});
}
internal Mock <QueryObjectBase <TDto, TEntity, TFilterDto, IQuery <TEntity> > > GetQueryObjectMock
<TDto, TEntity, TFilterDto>(QueryResultDto <TDto, TFilterDto> toReturn)
where TEntity : class, IEntity, new()
where TFilterDto : FilterDtoBase
{
var queryObjectMock = new Mock <QueryObjectBase <TDto, TEntity, TFilterDto, IQuery <TEntity> > >(null, null);
queryObjectMock.Setup(queryObject => queryObject.ExecuteQuery(It.IsAny <TFilterDto>()))
.ReturnsAsync(toReturn);
return(queryObjectMock);
}
private PostListViewModel InitializePostListViewModel(QueryResultDto <PostDto, PostFilterDto> postsResult,
List <List <ImageDto> > imagesResult, List <List <Tuple <int, int> > > hashtagIndices)
{
return(new PostListViewModel
{
Posts = new StaticPagedList <PostDto>(postsResult.Items, postsResult.RequestedPageNumber ?? 1, PostsPageSize,
(int)postsResult.TotalItemsCount),
ImagesForPosts = imagesResult,
HashtagIndices = hashtagIndices,
PostFilter = postsResult.Filter,
});
}
private PostListViewModel InitializePostListViewModel(QueryResultDto <PostDto, PostFilterDto> postsResult,
List <List <ImageDto> > imagesResult)
{
return(new PostListViewModel
{
Posts = new StaticPagedList <PostDto>(postsResult.Items, postsResult.RequestedPageNumber ?? 1, PostsPageSize,
(int)postsResult.TotalItemsCount),
ImagesForPosts = imagesResult,
HashtagIndices = postsResult.Items.Select(p => PostFacade.FindHashtagIndices(p.Text)).ToList(),
PostFilter = postsResult.Filter,
});
}
private static EmployerFacade CreateFacade(QueryResultDto <EmployerDto, EmployerFilterDto> expectedQueryResult)
{
var mockManager = new FacadeMockManager();
var uowMock = FacadeMockManager.ConfigureUowMock();
var mapper = FacadeMockManager.ConfigureRealMapper();
var repositoryMock = new Mock <IEmployerRepository>(MockBehavior.Loose);
var queryMock =
mockManager.ConfigureQueryObjectMock <EmployerDto, Employer, EmployerFilterDto>(expectedQueryResult);
var customerService = new EmployerService(mapper, repositoryMock.Object, queryMock.Object, new AuthenticationService());
var customerFacade = new EmployerFacade(uowMock.Object, customerService);
return(customerFacade);
}
public async Task GetAllUsersAsync_NoUsers_ReturnEmptyResult()
{
var expectedQueryResult = new QueryResultDto <UserDto, UserFilterDto>
{
Items = new List <UserDto>()
};
var userFacade = CreateUserFacade(expectedQueryResult);
var actualUsers = await userFacade.GetAllUsersAsync();
Assert.Equal(expectedQueryResult.Items, actualUsers);
}
private static PostFacade CreateUserFacade(QueryResultDto <PostDto, PostFilterDto> expectedQueryResult)
{
var mockManager = new FacadeMockManager();
var uowMock = FacadeMockManager.ConfigureUowMock();
var mapper = FacadeMockManager.ConfigureRealMapper();
var repositoryMock = mockManager.ConfigureRepositoryMock <Post>();
//Druhy zpusob porovnani, vice genericky nez v User testech ale mene presny
var queryMock = mockManager.ConfigureQueryObjectMock <PostDto, Post, PostFilterDto>(expectedQueryResult);
var postService = new PostService(mapper, repositoryMock.Object, queryMock.Object);
var crudService = new CrudQueryServiceBase <Post, PostDto, PostFilterDto>(mapper, repositoryMock.Object, queryMock.Object);
var postFacade = new PostFacade(uowMock.Object, crudService, postService);
return(postFacade);
}
private FriendListViewModel InitializeFriendListViewModel(QueryResultDto <UserDto, FriendshipFilterDto> friends)
{
int page = friends.RequestedPageNumber ?? 1;
return(new FriendListViewModel
{
Friends = new StaticPagedList <UserDto>(
friends.Items,
page,
friends.PageSize,
(int)friends.TotalItemsCount),
Filter = friends.Filter
});
}
private MessageListViewModel InitializeMessageListViewModel(QueryResultDto <MessageDto, MessageFilterDto> messages)
{
int page = messages.RequestedPageNumber ?? 1;
messages.Items = messages.Items.OrderBy(message => message.Time);
return(new MessageListViewModel
{
Messages = new StaticPagedList <MessageDto>(
messages.Items,
page,
messages.PageSize,
(int)messages.TotalItemsCount),
Filter = messages.Filter
});
}
private static CustomerFacade CreateCustomerFacade(QueryResultDto <CustomerDto, CustomerFilterDto> expectedQueryResult)
{
var mockManager = new FacadeMockManager();
var uowMock = FacadeMockManager.ConfigureUowMock();
var mapper = FacadeMockManager.ConfigureRealMapper();
var customerRepositoryMock = mockManager.ConfigureRepositoryMock <Artist>();
var userRepositoryMock = mockManager.ConfigureRepositoryMock <User>();
var customerQueryMock = mockManager.ConfigureQueryObjectMock <CustomerDto, Artist, CustomerFilterDto>(expectedQueryResult);
var userQueryMock = mockManager.ConfigureQueryObjectMock <UserDto, User, UserFilterDto>(null);
var customerService = new CustomerService(mapper, customerRepositoryMock.Object, customerQueryMock.Object);
var userService = new UserService(mapper, customerRepositoryMock.Object, userQueryMock.Object);
var customerFacade = new CustomerFacade(uowMock.Object, customerService, userService);
return(customerFacade);
}
public async Task GetDoctorSpecializationAsync()
{
var doctorId = Guid.Parse("00000000-0000-0000-0000-000000000011");
const string name = "John";
const string surname = "Malecki";
const Specialization specialization = Specialization.Cardiologist;
var doctorId2 = Guid.Parse("00000000-0000-0000-0000-000000000011");
const string name2 = "Pavel";
const string surname2 = "Loungry";
const Specialization specialization2 = Specialization.Cardiologist;
var doctorDto1 = new DoctorDto
{
Id = doctorId,
Name = name,
Surname = surname,
Specialization = specialization
};
var doctorDto2 = new DoctorDto
{
Id = doctorId2,
Name = name2,
Surname = surname2,
Specialization = specialization2
};
var expectedResult = new List <DoctorDto> {
doctorDto1, doctorDto2
};
var returnedResult = new QueryResultDto <DoctorDto, DoctorFilterDto>
{
Items = expectedResult
};
var mockManager = new FacadeMockManager();
var doctorRepositoryMock = mockManager.ConfigureRepositoryMock <Doctor>();
var doctorQueryMock = mockManager.ConfigureQueryObjectMock <DoctorDto, Doctor, DoctorFilterDto>(returnedResult);
var doctorFacade = CreateDoctorFacade(doctorQueryMock, doctorRepositoryMock);
var actualResult = await doctorFacade.GetDoctorBySpecializationAsync("Cardiologist");
Assert.AreEqual(actualResult, expectedResult);
}
private static UserFacade CreateUserFacade(QueryResultDto <UserDto, UserFilterDto> result)
{
var mockFacadeManager = new FacadeMockManager();
var uowMock = FacadeMockManager.GetUowMock();
var mapperMock = FacadeMockManager.GetMapper();
var repositoryMock = mockFacadeManager.GetRepositoryMock <User>();
var repositoryLoginMock = mockFacadeManager.GetRepositoryMock <UserLogin>();
var userQueryObjectMock = mockFacadeManager.GetQueryObjectMock <UserDto, User, UserFilterDto>(result);
var userLoginQueryObjectMock =
mockFacadeManager.GetQueryObjectMock <UserLoginDto, UserLogin, UserLoginFilterDto>(null);
var userService = new UserService(mapperMock, repositoryMock.Object, userQueryObjectMock.Object);
var userLoginService = new UserLoginService(mapperMock, repositoryLoginMock.Object,
userLoginQueryObjectMock.Object);
var userFacade = new UserFacade(uowMock.Object, userService, userLoginService);
return(userFacade);
}
public async Task GetAllCustomersAsync_TwoExistingCustomers_ReturnsCorrectQueryResult()
{
var expectedQueryResult = new QueryResultDto <CustomerDto, CustomerFilterDto>
{
Filter = new CustomerFilterDto(),
Items = new List <CustomerDto> {
new CustomerDto {
Id = Guid.NewGuid()
}, new CustomerDto {
Id = Guid.NewGuid()
}
},
PageSize = 10,
RequestedPageNumber = null
};
var customerFacade = CreateCustomerFacade(expectedQueryResult);
var actualQueryResult = await customerFacade.GetAllCustomersAsync();
Assert.AreEqual(actualQueryResult, expectedQueryResult);
}
public async Task GetCustomerAccordingToEmailAsync_ExistingCustomer_ReturnsCorrectCustomer()
{
const string customerEmail = "*****@*****.**";
var expectedCustomer = new CustomerDto
{
Id = Guid.NewGuid(),
FirstName = "John",
LastName = "Doe",
Email = customerEmail
};
var expectedQueryResult = new QueryResultDto <CustomerDto, CustomerFilterDto> {
Items = new List <CustomerDto> {
expectedCustomer
}
};
var customerFacade = CreateCustomerFacade(expectedQueryResult);
var actualCustomer = await customerFacade.GetCustomerAccordingToEmailAsync(customerEmail);
Assert.AreEqual(actualCustomer, expectedCustomer);
}
public QueryResultDto GetUsers(FilterUserDto filterUser)
{
var allUsers = _context.Users
.Include(x => x.Schooling)
.Where(UserQueries.GetAll(filterUser))
.AsNoTracking();
var users = allUsers.OrderBy(x => x.Id)
.Skip(filterUser.CountSkip)
.Take(filterUser.QuantityPerPage)
.AsNoTracking();
var result = new QueryResultDto();
result.Page = filterUser.Page;
result.QuantityPerPage = filterUser.QuantityPerPage;
result.NumberOfRecords = allUsers.Count();
result.List = _mapper.Map <List <UserDto> >(users);
return(result);
}
public async Task GetAllUsersAsync_TwoExistingUsers_ReturnCorrectResult()
{
var expectedQueryResult = new QueryResultDto <UserDto, UserFilterDto>
{
Items = new List <UserDto>
{
new UserDto {
Id = Guid.NewGuid()
},
new UserDto {
Id = Guid.NewGuid()
}
}
};
var userFacade = CreateUserFacade(expectedQueryResult);
var actualResult = await userFacade.GetAllUsersAsync();
Assert.Equal(expectedQueryResult.Items, actualResult);
}
public async Task GetUsersContainingGivenSubnameAsyncTest()
{
var expectedUsers = new List <UserDto>
{
new UserDto
{
Id = 1,
NickName = "Misko"
},
new UserDto
{
Id = 2,
NickName = "Misko2"
}
};
var expectedQueryResult = new QueryResultDto <UserDto, UserFilterDto> {
Items = expectedUsers
};
var uowMock = FacadeMockManager.ConfigureUowMock();
//nepouzivam genericky FacadeMockManager, vytvarim si vlastni queryMock -> vice kodu ale presnejsi -> viz dalsi komentar
var queryMock = new Mock <UserQueryObject>(MockBehavior.Strict, null, null);
queryMock
.Setup(x => x.ExecuteQuery(new UserFilterDto
{
SubName = "Misko"
}))
.ReturnsAsync(expectedQueryResult);
var userService = new UserService(null, null, queryMock.Object);
var crudService = new CrudQueryServiceBase <User, UserDto, UserFilterDto>(null, null, queryMock.Object);
var userFacade = new UserGenericFacade(uowMock.Object, crudService, userService);
//Pokud zde totiz zmenim Misko na napr "zlyMisko" tak uz to neprochazi -> U PostFacadeTestu vsak prochazi -> vice komentaru tam
var actualUsers = await userFacade.GetUsersContainingSubNameAsync("Misko");
Assert.AreEqual(expectedUsers, actualUsers);
}
public async Task GetEmployerAccordingToNameAsync_ExistingEmployer_ReturnsCorrectEmployer()
{
const string name = "Dilino";
var expectedEmployer = new EmployerDto()
{
Id = 1,
Name = name,
Email = "*****@*****.**",
Address = ":D",
PhoneNumber = "+421910987654"
};
var expectedQueryResult =
new QueryResultDto <EmployerDto, EmployerFilterDto> {
Items = new List <EmployerDto> {
expectedEmployer
}
};
var customerFacade = CreateFacade(expectedQueryResult);
var actualCustomer = await customerFacade.GetEmployerByName(name);
Assert.AreEqual(actualCustomer, expectedEmployer);
}
public async Task CreateProductWithCategoryNameAsync_ExistingProduct_ReturnsCorrectCustomer()
{
const string categoryName = "Android";
var categoryId = Guid.NewGuid();
var returnedResult = new QueryResultDto <CategoryDto, CategoryFilterDto>
{
Items = new List <CategoryDto> {
new CategoryDto {
Id = categoryId
}
}
};
var mockManager = new FacadeMockManager();
var productRepositoryMock = mockManager.ConfigureCreateRepositoryMock <Song>(nameof(Song.CategoryId));
var categoryRepositoryMock = mockManager.ConfigureRepositoryMock <Album>();
var productQueryMock = mockManager.ConfigureQueryObjectMock <ProductDto, Song, ProductFilterDto>(null);
var categoryQueryMock = mockManager.ConfigureQueryObjectMock <CategoryDto, Album, CategoryFilterDto>(returnedResult);
var productFacade = await CreateProductFacade(productQueryMock, productRepositoryMock, categoryRepositoryMock, categoryQueryMock);
var unused = await productFacade.CreateProductWithCategoryNameAsync(new ProductDto { Id = Guid.NewGuid() }, categoryName);
Assert.AreEqual(categoryId, mockManager.CapturedCreatedId);
}
