public async Task ReturnValid_StringFilter() { //Arrange var mockIDateTimeProvider = new Mock <IDateTimeProvider>(); var mockIBarReviewService = new Mock <IBarReviewService>(); var mockIBarMapper = new Mock <IBarMapper>(); mockIBarMapper .Setup(x => x.MapToBarDTO(It.IsAny <Bar>())) .Returns <Bar>(b => new BarDTO { Id = b.Id, Name = b.Name }); var filter = "lOr"; var orderBy = "name"; var direction = "asc"; var options = Utils.GetOptions(nameof(ReturnValid_StringFilter)); Utils.GetInMemoryDataBase(options); //Act & Assert using (var assertContext = new CocktailMagicianContext(options)) { var sut = new BarService(mockIDateTimeProvider.Object, assertContext, mockIBarMapper.Object, mockIBarReviewService.Object); var result = await sut.ListAllBarsAsync(0, 10, filter, orderBy, direction); var expectedBar = result.FirstOrDefault(x => x.Name == "Lorka"); Assert.AreEqual(1, result.Count); Assert.AreEqual("Lorka", expectedBar.Name); } }
public async Task ReturnUpdatedCityDTO_WhenParamsAreValid() { //Arrange var mockIDateTimeProvider = new Mock <IDateTimeProvider>(); var mockICityMapper = new Mock <ICityMapper>(); var mockIBarMapper = new Mock <IBarMapper>(); var options = Utils.GetOptions(nameof(ReturnUpdatedCityDTO_WhenParamsAreValid)); var updatedCityDTO = new CityDTO { Id = 2, Name = "Shumen" }; mockICityMapper .Setup(x => x.MapToCityDTO(It.IsAny <City>())) .Returns <City>(c => new CityDTO { Id = c.Id, Name = c.Name }); Utils.GetInMemoryDataBase(options); //Act & Assert using (var assertContext = new CocktailMagicianContext(options)) { var sut = new CityService(mockIDateTimeProvider.Object, assertContext, mockICityMapper.Object, mockIBarMapper.Object); var result = await sut.UpdateCityAsync(2, updatedCityDTO); Assert.AreEqual(updatedCityDTO.Id, result.Id); Assert.AreEqual(updatedCityDTO.Name, result.Name); } }
public async Task ReturnNull_IfCityDoesNotExist() { //Arrange var mockIDateTimeProvider = new Mock <IDateTimeProvider>(); var mockICityMapper = new Mock <ICityMapper>(); var mockIBarMapper = new Mock <IBarMapper>(); var options = Utils.GetOptions(nameof(ReturnNull_IfCityDoesNotExist)); var updatedCityDTO = new CityDTO { Id = 1, Name = "Varna" }; mockICityMapper .Setup(x => x.MapToCityDTO(It.IsAny <City>())) .Returns <City>(c => new CityDTO { Id = c.Id, Name = c.Name }); Utils.GetInMemoryDataBase(options); //Act & Assert using (var assertContext = new CocktailMagicianContext(options)) { var sut = new CityService(mockIDateTimeProvider.Object, assertContext, mockICityMapper.Object, mockIBarMapper.Object); var result = await sut.UpdateCityAsync(4, updatedCityDTO); Assert.IsNull(result); } }
public CityService(IDateTimeProvider dateTimeProvider, CocktailMagicianContext context, ICityMapper cityMapper, IBarMapper barMapper) { this.dateTimeProvider = dateTimeProvider ?? throw new ArgumentNullException(nameof(dateTimeProvider)); this.context = context ?? throw new ArgumentNullException(nameof(context)); this.cityMapper = cityMapper ?? throw new ArgumentNullException(nameof(cityMapper)); this.barMapper = barMapper ?? throw new ArgumentNullException(nameof(barMapper)); }
public async Task ReturnEmpty_IfNoMatchesFound() { //Arrange var mockIDateTimeProvider = new Mock <IDateTimeProvider>(); var mockIBarReviewService = new Mock <IBarReviewService>(); var mockIBarMapper = new Mock <IBarMapper>(); mockIBarMapper .Setup(x => x.MapToBarDTO(It.IsAny <Bar>())) .Returns <Bar>(b => new BarDTO { Id = b.Id, Name = b.Name }); var filter = "ZzzZ"; var orderBy = "name"; var direction = "asc"; var options = Utils.GetOptions(nameof(ReturnEmpty_IfNoMatchesFound)); Utils.GetInMemoryDataBase(options); //Act & Assert using (var assertContext = new CocktailMagicianContext(options)) { var sut = new BarService(mockIDateTimeProvider.Object, assertContext, mockIBarMapper.Object, mockIBarReviewService.Object); var result = await sut.ListAllBarsAsync(0, 10, filter, orderBy, direction); Assert.AreEqual(0, result.Count); } }
public async Task Throw_When_DtoIngredientsIsNull() { //Arrange var options = TestUtilities.GetOptions(nameof(Throw_When_DtoIngredientsIsNull)); var mockCocktailDtoMapper = new Mock <IDtoMapper <Cocktail, CocktailDto> >(); var mockCocktailIngretientService = new Mock <ICocktailIngredientService>(); var mockIngredientsService = new Mock <IIngredientService>(); var mockDateTimeProvider = new Mock <IDateTimeProvider>(); string[] ingredients = new string[] { }; var cocktailDto = new CocktailDto { Id = 1, Name = "TestCocktail", Ingredients = ingredients, }; //Act and Assert using (var assertContext = new CocktailMagicianContext(options)) { var sut = new CocktailService(assertContext, mockCocktailDtoMapper.Object, mockDateTimeProvider.Object, mockCocktailIngretientService.Object, mockIngredientsService.Object); await Assert.ThrowsExceptionAsync <ArgumentNullException>(() => sut.CreateCocktailAsync(cocktailDto)); } }
public async Task CreateCorrect_Ingredient() { //Arrange var options = TestUtilities.GetOptions(nameof(CreateCorrect_Ingredient)); var mapper = new Mock <IDtoMapper <Ingredient, IngredientDto> >(); var mockDateTimeProvider = new Mock <IDateTimeProvider>(); var ingredientDto = new IngredientDto { Name = "Cola" }; mapper.Setup(x => x.MapDto(It.IsAny <Ingredient>())).Returns(ingredientDto); using (var assertContext = new CocktailMagicianContext(options)) { //Act & Assert var sut = new IngredientService(assertContext, mapper.Object, mockDateTimeProvider.Object); var result = await sut.CreateIngredientAsync(ingredientDto); Assert.IsInstanceOfType(result, typeof(IngredientDto)); Assert.AreEqual(0, result.Id); Assert.AreEqual("Cola", result.Name); } }
public async Task ReturnCReviewDTO_IfParamsAreValid() { //Arrange var mockIDateTimeProvider = new Mock <IDateTimeProvider>(); var mockICocktailReviewMapper = new Mock <ICocktailReviewMapper>(); mockICocktailReviewMapper .Setup(r => r.MapToCocktailReviewDTO(It.IsAny <CocktailsUsersReviews>())) .Returns <CocktailsUsersReviews>(r => new CocktailReviewDTO { CocktailId = r.CocktailId, AuthorId = r.UserId, Comment = r.Comment }); var options = Utils.GetOptions(nameof(ReturnCReviewDTO_IfParamsAreValid)); Utils.GetInMemoryDataBase(options); //Act & Assert using (var assertContext = new CocktailMagicianContext(options)) { var sut = new CocktailReviewService(mockIDateTimeProvider.Object, assertContext, mockICocktailReviewMapper.Object); var result = await sut.GetCocktailReviewAsync(1, 2); Assert.AreEqual(1, result.CocktailId); Assert.AreEqual(2, result.AuthorId); } }
public async Task Delete_Cocktail_Correctly() { //Arrange var options = TestUtilities.GetOptions(nameof(Delete_Cocktail_Correctly)); var mockCocktailDtoMapper = new Mock <IDtoMapper <Cocktail, CocktailDto> >(); var mockCocktailIngretientService = new Mock <ICocktailIngredientService>(); var mockIngredientsService = new Mock <IIngredientService>(); var mockDateTimeProvider = new Mock <IDateTimeProvider>(); var cocktail = new Cocktail { Id = 1, Name = "TestCocktail", }; using (var arrangeContext = new CocktailMagicianContext(options)) { await arrangeContext.Cocktails.AddAsync(cocktail); await arrangeContext.SaveChangesAsync(); var cocktailService = new CocktailService(arrangeContext, mockCocktailDtoMapper.Object, mockDateTimeProvider.Object, mockCocktailIngretientService.Object, mockIngredientsService.Object); var result = await cocktailService.DeleteCocktailAsync(1); } //Act and Assert using (var assertContext = new CocktailMagicianContext(options)) { var deletedCocktail = await assertContext.Cocktails.FirstAsync(); Assert.IsTrue(deletedCocktail.IsDeleted); } }
public async Task Throw_When_NoCocktailsFound() { //Arrange var options = TestUtilities.GetOptions(nameof(Throw_When_NoCocktailsFound)); var mockCocktailDtoMapper = new Mock <IDtoMapper <Cocktail, CocktailDto> >(); var mockCocktailIngretientService = new Mock <ICocktailIngredientService>(); var mockIngredientsService = new Mock <IIngredientService>(); var mockDateTimeProvider = new Mock <IDateTimeProvider>(); var cocktailDto = new CocktailDto { Id = 1, Name = "NewTestCocktail", ShortDescription = "NewTestShortDescription", LongDescription = "NewTestLongDescription", }; //Act and Assert using (var assertContext = new CocktailMagicianContext(options)) { var sut = new CocktailService(assertContext, mockCocktailDtoMapper.Object, mockDateTimeProvider.Object, mockCocktailIngretientService.Object, mockIngredientsService.Object); await Assert.ThrowsExceptionAsync <ArgumentNullException>(() => sut.UpdateCocktailAsync(cocktailDto)); } }
public void ReturnCorrectCountOfFilteredIngredients() { //Arrange var mockDateTimeProvider = new Mock <IDateTimeProvider>(); var mockIngMapper = new Mock <IIngredientMapper>(); mockIngMapper.Setup(i => i.MapToIngredientDTO(It.IsAny <Ingredient>())) .Returns <Ingredient>(i => new IngredientDTO { Name = i.Name }); var mockCocktailMapper = new Mock <ICocktailMapper>(); var options = Utils.GetOptions(nameof(ReturnCorrectCountOfFilteredIngredients)); Utils.GetInMemoryDataBase(options); //Act & Assert using (var assertContext = new CocktailMagicianContext(options)) { var sut = new IngredientService(mockDateTimeProvider.Object, mockIngMapper.Object, mockCocktailMapper.Object, assertContext); var result = sut.GetAllFilteredIngredientsCount("o"); Assert.AreEqual(2, result); } }
public async Task Delete_Bar_Correctly() { //Arrange var options = TestUtilities.GetOptions(nameof(Delete_Bar_Correctly)); var mockDateTimeProvider = new Mock <IDateTimeProvider>(); var mockBarDtoMapper = new Mock <IDtoMapper <Bar, BarDTO> >(); var newBar = new Bar { Id = 1, Name = "TestBar", }; using (var arrangeContext = new CocktailMagicianContext(options)) { await arrangeContext.Bars.AddAsync(newBar); await arrangeContext.SaveChangesAsync(); var barService = new BarService(arrangeContext, mockBarDtoMapper.Object, mockDateTimeProvider.Object); var result = await barService.DeleteBarAsync(1); } //Act and Assert using (var assertContext = new CocktailMagicianContext(options)) { var deletedBar = await assertContext.Bars.FirstAsync(); Assert.IsTrue(deletedBar.IsDeleted); } }
public async Task ReturnCorrectIngredientsAsync() { //Arrange var mockDatetimeProvider = new Mock <IDateTimeProvider>(); var mockMapper = new Mock <IIngredientMapper>(); mockMapper.Setup(i => i.MapToIngredientDTO(It.IsAny <Ingredient>())) .Returns <Ingredient>(i => new IngredientDTO { Id = i.Id, Name = i.Name }); var mockCocktailMapper = new Mock <ICocktailMapper>(); var options = Utils.GetOptions(nameof(ReturnCorrectIngredientsAsync)); Utils.GetInMemoryDataBase(options); // Act & Assert using (var assertContext = new CocktailMagicianContext(options)) { var sut = new IngredientService(mockDatetimeProvider.Object, mockMapper.Object, mockCocktailMapper.Object, assertContext); var result = (await sut.GetAllIngredientsAsync()).ToList(); var ingredientsCount = assertContext.Ingredients.Count(); Assert.AreEqual(ingredientsCount, result.Count); } }
public async Task ReturnTrue_IfCocktailReviewDeletedSuccesfully() { //Arrange var mockIDateTimeProvider = new Mock <IDateTimeProvider>(); var mockICocktailReviewMapper = new Mock <ICocktailReviewMapper>(); var options = Utils.GetOptions(nameof(ReturnTrue_IfCocktailReviewDeletedSuccesfully)); var review = new CocktailsUsersReviews { CocktailId = 1, UserId = 2, Comment = "Top!", Rating = 5 }; Utils.GetInMemoryDataBase(options); //Act & Assert using (var assertContext = new CocktailMagicianContext(options)) { var sut = new CocktailReviewService(mockIDateTimeProvider.Object, assertContext, mockICocktailReviewMapper.Object); var result = await sut.DeleteCocktailReviewAsync(1, 2); var deletedReview = assertContext.CocktailsUsersReviews .FirstOrDefault(r => r.CocktailId == 1 && r.UserId == 2); Assert.IsTrue(result); Assert.AreEqual(true, deletedReview.IsDeleted); } }
public async Task ReturnCorrectCocktails() { //Arrange var mockDateTimeProvider = new Mock <IDateTimeProvider>(); var mockCocktailMapper = new Mock <ICocktailMapper>(); mockCocktailMapper.Setup(c => c.MapToCocktailDTO(It.IsAny <Cocktail>())) .Returns <Cocktail>(c => new CocktailDTO { Id = c.Id, Name = c.Name, AverageRating = c.AverageRating }); var mockIngMapper = new Mock <IIngredientMapper>(); var mockBarMapper = new Mock <IBarMapper>(); var mockCocktailReviewService = new Mock <ICocktailReviewService>(); var options = Utils.GetOptions(nameof(ReturnCorrectCocktails)); Utils.GetInMemoryDataBase(options); //Act & Assert using (var assertContext = new CocktailMagicianContext(options)) { var sut = new CocktailService(mockDateTimeProvider.Object, mockCocktailMapper.Object, mockIngMapper.Object, mockBarMapper.Object, assertContext, mockCocktailReviewService.Object); var result = (await sut.GetAllCocktailssAsync()).ToList(); var cocktailsCount = assertContext.Cocktails.Count(); Assert.AreEqual(cocktailsCount, result.Count); } }
public async Task ReturnFalse_WhenIdNotFound() { //Arrange var mockDatetimeProvider = new Mock <IDateTimeProvider>(); var mockMapper = new Mock <IIngredientMapper>(); mockMapper.Setup(i => i.MapToIngredientDTO(It.IsAny <Ingredient>())) .Returns <Ingredient>(i => new IngredientDTO { Name = i.Name }); var mockCocktailMapper = new Mock <ICocktailMapper>(); var options = Utils.GetOptions(nameof(ReturnFalse_WhenIdNotFound)); Utils.GetInMemoryDataBase(options); //Act & Assert using (var assertContext = new CocktailMagicianContext(options)) { var sut = new IngredientService(mockDatetimeProvider.Object, mockMapper.Object, mockCocktailMapper.Object, assertContext); var result = await sut.DeleteIngredientAsync(9); Assert.IsFalse(result); } }
public async Task ReturnNull_NoUserToUpdate() { //Arrange var mockDatetimeProvider = new Mock <IDateTimeProvider>(); var mockIUserMapper = new Mock <IUserMapper>(); var options = Utils.GetOptions(nameof(ReturnNull_NoUserToUpdate)); var userDTO = new UserDTO { UserName = "******", Email = "*****@*****.**", PhoneNumber = "0833 333 333" }; Utils.GetInMemoryDataBase(options); //Act & Assert using (var assertContext = new CocktailMagicianContext(options)) { var sut = new UserService(mockDatetimeProvider.Object, assertContext, mockIUserMapper.Object); var result = await sut.UpdateUserAsync(3, userDTO); Assert.IsNull(result); } }
public BarService(IDateTimeProvider dateTimeProvider, CocktailMagicianContext context, IBarMapper barMapper, IBarReviewService reviewService) { this.dateTimeProvider = dateTimeProvider ?? throw new ArgumentNullException(nameof(dateTimeProvider)); this.context = context ?? throw new ArgumentNullException(nameof(context));; this.barMapper = barMapper ?? throw new ArgumentNullException(nameof(barMapper)); this.reviewService = reviewService ?? throw new ArgumentNullException(nameof(reviewService)); }
public void CorrectMapping_ToEntityModel() { //Arrange var options = Utils.GetOptions(nameof(CorrectMapping_ToEntityModel)); //Act & Assert using (var assertContext = new CocktailMagicianContext(options)) { var cocktailDTO = new CocktailDTO { Id = 5, Name = "Cuba Libre", AverageRating = 3.5, IsDeleted = false }; var sut = new CocktailMapper(); var result = sut.MapToCocktail(cocktailDTO); Assert.IsInstanceOfType(result, typeof(Cocktail)); Assert.AreEqual(cocktailDTO.Id, result.Id); Assert.AreEqual(cocktailDTO.Name, result.Name); Assert.AreEqual(cocktailDTO.AverageRating, result.AverageRating); Assert.AreEqual(cocktailDTO.IsDeleted, result.IsDeleted); } }
public void CorrectMapping_ToBar() { //Arrange var options = Utils.GetOptions(nameof(CorrectMapping_ToBar)); //Act & Assert using (var assertContext = new CocktailMagicianContext(options)) { var barDTO = new BarDTO { Name = "Bilkova", CityId = 1, Address = "Shishman str.", Phone = "0888 888 444", AverageRating = 4, }; var sut = new BarMapper(); var result = sut.MapToBar(barDTO); Assert.IsInstanceOfType(result, typeof(Bar)); Assert.AreEqual(barDTO.Name, result.Name); Assert.AreEqual(barDTO.CityId, result.CityId); Assert.AreEqual(barDTO.Address, result.Address); Assert.AreEqual(barDTO.Phone, result.Phone); Assert.AreEqual(barDTO.AverageRating, result.AverageRating); } }
public async Task Return_ProperBarCount() { //Arrange var mockIDateTimeProvider = new Mock <IDateTimeProvider>(); var mockIBarReviewService = new Mock <IBarReviewService>(); var mockIBarMapper = new Mock <IBarMapper>(); mockIBarMapper.Setup(b => b.MapToBarDTO(It.IsAny <Bar>())) .Returns <Bar>(b => new BarDTO { Name = b.Name }); var options = Utils.GetOptions(nameof(Return_ProperBarCount)); Utils.GetInMemoryDataBase(options); //Act & Assert using (var assertContext = new CocktailMagicianContext(options)) { var sut = new BarService(mockIDateTimeProvider.Object, assertContext, mockIBarMapper.Object, mockIBarReviewService.Object); var result = await sut.GetAllBarsAsync(); int barsCount = assertContext.Bars.Count(); Assert.AreEqual(barsCount, result.Count); } }
public async Task Return_CorrectUserParams() { //Arrange var mockDatetimeProvider = new Mock <IDateTimeProvider>(); var mockIUserMapper = new Mock <IUserMapper>(); mockIUserMapper .Setup(x => x.MapToUserDTO(It.IsAny <User>())) .Returns <User>(x => new UserDTO { Id = x.Id, UserName = x.UserName, Email = x.Email, PhoneNumber = x.PhoneNumber }); mockIUserMapper .Setup(x => x.MapToUser(It.IsAny <UserDTO>())) .Returns <UserDTO>(x => new User { UserName = x.UserName, Email = x.Email, PhoneNumber = x.PhoneNumber }); var options = Utils.GetOptions(nameof(Return_CorrectUserParams)); Utils.GetInMemoryDataBase(options); //Act & Assert using (var assertContext = new CocktailMagicianContext(options)) { var sut = new UserService(mockDatetimeProvider.Object, assertContext, mockIUserMapper.Object); var result = await sut.GetUserAsync(2); Assert.AreEqual(2, result.Id); Assert.AreEqual("Jim", result.UserName); } }
public async Task ReturnIngredient_WhenFound() { //Arrange var mockDatetimeProvider = new Mock <IDateTimeProvider>(); var mockMapper = new Mock <IIngredientMapper>(); mockMapper.Setup(i => i.MapToIngredientDTO(It.IsAny <Ingredient>())) .Returns <Ingredient>(i => new IngredientDTO { Id = i.Id, Name = i.Name }); var mockCocktailMapper = new Mock <ICocktailMapper>(); var options = Utils.GetOptions(nameof(ReturnIngredient_WhenFound)); var expected = new IngredientDTO { Id = 1, Name = "Rum" }; Utils.GetInMemoryDataBase(options); //Act & Assert using (var assertContext = new CocktailMagicianContext(options)) { var sut = new IngredientService(mockDatetimeProvider.Object, mockMapper.Object, mockCocktailMapper.Object, assertContext); var result = await sut.GetIngredientAsync(1); Assert.AreEqual(expected.Id, result.Id); Assert.AreEqual(expected.Name, result.Name); } }
public async Task UpdateIngredient_WhenParamsAreValid() { //Arrange var mockDateTiemProvider = new Mock <IDateTimeProvider>(); var mockMapper = new Mock <IngredientMapper>(); var mockCocktailMapper = new Mock <CocktailMapper>(); var options = Utils.GetOptions(nameof(UpdateIngredient_WhenParamsAreValid)); var expected = new IngredientDTO { Id = 2, Name = "Portocal Juice" }; Utils.GetInMemoryDataBase(options); //Act & Assert using (var assertContext = new CocktailMagicianContext(options)) { var sut = new IngredientService(mockDateTiemProvider.Object, mockMapper.Object, mockCocktailMapper.Object, assertContext); var result = await sut.UpdateIngredientAsync(2, expected); Assert.AreEqual(expected.Name, result.Name); } }
public void CorrectMapping_ToCocktaiDTO() { //Arrange var options = Utils.GetOptions(nameof(CorrectMapping_ToCocktaiDTO)); Utils.GetInMemoryDataBase(options); //Act & Assert using (var assertCocntext = new CocktailMagicianContext(options)) { var cocktail = assertCocntext.Cocktails .Include(bar => bar.CocktailBars) .ThenInclude(b => b.Bar) .Include(ingr => ingr.IngredientsCocktails) .ThenInclude(i => i.Ingredient) .Include(c => c.Creator) .FirstOrDefault(x => x.Id == 1); var sut = new CocktailMapper(); var result = sut.MapToCocktailDTO(cocktail); Assert.IsInstanceOfType(result, typeof(CocktailDTO)); Assert.AreEqual(cocktail.Id, result.Id); Assert.AreEqual(cocktail.Name, result.Name); Assert.AreEqual(cocktail.AverageRating, result.AverageRating); Assert.AreEqual(cocktail.IsDeleted, result.IsDeleted); Assert.AreEqual(cocktail.IngredientsCocktails.Count, result.Ingredients.Count); Assert.AreEqual(cocktail.CocktailBars.Count, result.Bars.Count); } }
public async Task CreateCorrectInstance_Of_Type_BarDto() { //Arrange var options = TestUtilities.GetOptions(nameof(CreateCorrectInstance_Of_Type_BarDto)); var mockDateTimeProvider = new Mock <IDateTimeProvider>(); var mockBarDtoMapper = new Mock <IDtoMapper <Bar, BarDTO> >(); var newBarDto = new BarDTO { Id = 1, Name = "TestBar", Info = "TestInfo", Address = "TestAddress", PhotoPath = "TestPath", }; mockBarDtoMapper.Setup(x => x.MapDto(It.IsAny <Bar>())).Returns(newBarDto); //Act and Assert using (var assertContext = new CocktailMagicianContext(options)) { var sut = new BarService(assertContext, mockBarDtoMapper.Object, mockDateTimeProvider.Object); var result = await sut.CreateBarAsync(newBarDto); Assert.IsInstanceOfType(result, typeof(BarDTO)); Assert.AreEqual(1, result.Id); Assert.AreEqual("TestBar", result.Name); Assert.AreEqual("TestInfo", result.Info); Assert.AreEqual("TestAddress", result.Address); Assert.AreEqual("TestPath", result.PhotoPath); } }
public async Task OrderCocktailsByRatingAscending() { //Arrange var mockDateTimeProvider = new Mock <IDateTimeProvider>(); var mockCocktailMapper = new Mock <ICocktailMapper>(); mockCocktailMapper .Setup(c => c.MapToCocktailDTO(It.IsAny <Cocktail>())) .Returns <Cocktail>(c => new CocktailDTO { Name = c.Name, AverageRating = c.AverageRating }); var mockIngMapper = new Mock <IIngredientMapper>(); mockIngMapper .Setup(i => i.MapToIngredientDTO(It.IsAny <Ingredient>())) .Returns <Ingredient>(i => new IngredientDTO { Name = i.Name }); var mockBarMapper = new Mock <IBarMapper>(); var mockCocktailReviewService = new Mock <ICocktailReviewService>(); var options = Utils.GetOptions(nameof(OrderCocktailsByRatingAscending)); var orderBy = "AverageRating"; var direction = "asc"; var expected = new List <CocktailDTO> { new CocktailDTO { Name = "Bozdugan", AverageRating = 3.8, }, new CocktailDTO { Name = "Mojito", AverageRating = 4.5, }, new CocktailDTO { Name = "Gin Fizz", AverageRating = 4.9 } }; Utils.GetInMemoryDataBase(options); //Act & Assert using (var assertContext = new CocktailMagicianContext(options)) { var sut = new CocktailService(mockDateTimeProvider.Object, mockCocktailMapper.Object, mockIngMapper.Object, mockBarMapper.Object, assertContext, mockCocktailReviewService.Object); var result = await sut.ListAllCocktailsAsync(0, 10, null, orderBy, direction); Assert.AreEqual(expected.Count, result.Count); for (int i = 0; i < expected.Count; i++) { Assert.AreEqual(expected[i].Name, result[i].Name); } } }
public CocktailService(CocktailMagicianContext context, IDtoMapper <Cocktail, CocktailDto> cocktailDtoMapper, IDateTimeProvider provider, ICocktailIngredientService cocktailIngredientService, IIngredientService ingredientService) { this._context = context ?? throw new ArgumentNullException(nameof(context)); this._cocktailDtoMapper = cocktailDtoMapper ?? throw new ArgumentNullException(nameof(cocktailDtoMapper)); this._provider = provider ?? throw new ArgumentNullException(nameof(provider)); this._cocktailIngredientService = cocktailIngredientService ?? throw new ArgumentNullException(nameof(cocktailIngredientService)); this._ingredientService = ingredientService ?? throw new ArgumentNullException(nameof(ingredientService)); }
public IngredientService(IDateTimeProvider datetimeProvider, IIngredientMapper mapper, ICocktailMapper cocktailMapper, CocktailMagicianContext context) { this.datetimeProvider = datetimeProvider ?? throw new ArgumentNullException(nameof(datetimeProvider)); this.mapper = mapper ?? throw new ArgumentNullException(nameof(mapper)); this.cocktailMapper = cocktailMapper ?? throw new ArgumentNullException(nameof(cocktailMapper)); this.context = context ?? throw new ArgumentNullException(nameof(context)); }
public async Task Create_Cocktail_Correctly() { //Arrange var options = TestUtilities.GetOptions(nameof(Create_Cocktail_Correctly)); var mockCocktailDtoMapper = new Mock <IDtoMapper <Cocktail, CocktailDto> >(); var mockCocktailIngretientService = new Mock <ICocktailIngredientService>(); var mockIngredientsService = new Mock <IIngredientService>(); var mockDateTimeProvider = new Mock <IDateTimeProvider>(); var ingredient = new Ingredient { Id = 1, Name = "TestIngredient" }; var ingredientDto = new IngredientDto { Id = 1, Name = "TestIngredient" }; string[] ingredients = new string[] { "TestIngredient" }; var cocktailDto = new CocktailDto { Id = 1, Name = "TestCocktail", Ingredients = ingredients, }; var cocktailIngredient = new CocktailIngredient { CocktailId = cocktailDto.Id, IngredientId = ingredient.Id }; mockCocktailDtoMapper.Setup(x => x.MapDto(It.IsAny <Cocktail>())).Returns(cocktailDto); mockIngredientsService.Setup(x => x.GetIngredientByNameAsync(It.IsAny <string>())) .Returns(Task.FromResult(ingredient)); mockCocktailIngretientService.Setup(x => x.CreateCocktailIngredientAsync(It.IsAny <int>(), It.IsAny <int>())).Returns(Task.FromResult(cocktailIngredient)); using (var arrangeContext = new CocktailMagicianContext(options)) { await arrangeContext.Ingredients.AddAsync(ingredient); await arrangeContext.SaveChangesAsync(); } //Act and Assert using (var assertContext = new CocktailMagicianContext(options)) { var sut = new CocktailService(assertContext, mockCocktailDtoMapper.Object, mockDateTimeProvider.Object, mockCocktailIngretientService.Object, mockIngredientsService.Object); var result = await sut.CreateCocktailAsync(cocktailDto); Assert.IsInstanceOfType(result, typeof(CocktailDto)); Assert.AreEqual(1, result.Id); Assert.AreEqual("TestCocktail", result.Name); Assert.AreEqual("TestIngredient", result.Ingredients.First()); } }