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); }