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