public async Task ThrowWhen_BarCocktailNotFound()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(ThrowWhen_BarCocktailNotFound));
var mapperMock = new Mock <IDtoMapper <Bar, BarDto> >();
var searchMapperMock = new Mock <IDtoMapper <Bar, SearchBarDto> >();
var cocktailMapperMock = new Mock <IDtoMapper <Cocktail, CocktailDto> >();
var testGuid = Guid.NewGuid();
var cocktailGuid = Guid.NewGuid();
var bar1 = new Bar
{
Id = testGuid,
Name = "testBar1",
};
var barDto1 = new BarDto
{
Id = testGuid,
Name = "testBar1",
};
var list = new List <string> {
"Boza"
};
var cocktail = new Cocktail {
Id = cocktailGuid, Name = "Boza"
};
mapperMock.Setup(x => x.MapFrom(It.IsAny <Bar>())).Returns(barDto1);
using (var arrangeContext = new CWContext(options))
{
await arrangeContext.Bars.AddAsync(bar1);
await arrangeContext.Cocktails.AddAsync(cocktail);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new CWContext(options))
{
//Act & Assert
var sut = new BarService(assertContext, mapperMock.Object, searchMapperMock.Object, cocktailMapperMock.Object);
await Assert.ThrowsExceptionAsync <BusinessLogicException>(() => sut.RemoveCocktailsAsync(barDto1, list));
}
}
public async Task ReturnCorrectBarCommentWhen_ParamsAreValid()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(ReturnCorrectBarCommentWhen_ParamsAreValid));
var mapperMock = new Mock <IDtoMapper <BarComment, BarCommentDto> >();
var id = Guid.NewGuid();
var barId = Guid.NewGuid();
var createdOn = DateTime.UtcNow;
var entity = new BarComment
{
Id = id,
BarId = barId,
UserId = Guid.NewGuid(),
Body = "testbody",
CreatedOn = createdOn
};
//var entityDto = new BarCommentDto
//{
// Id = id,
// BarId = barId,
// UserId = Guid.NewGuid(),
// Body = "testbody",
// CreatedOn = createdOn
//};
//mapperMock.Setup(x => x.MapFrom(It.IsAny<BarComment>())).Returns(entityDto);
using (var arrangeContext = new CWContext(options))
{
await arrangeContext.BarComments.AddAsync(entity);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new CWContext(options))
{
//Act & Assert
var sut = new BarCommentService(assertContext, mapperMock.Object);
//var result = await sut.GetBarCommentAsync(barId);
//Assert.IsInstanceOfType(result, typeof(BarComment));
//Assert.AreEqual("testbody", result.Body);
}
}
public async Task ThrowWhen_NoBarFound()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(ThrowWhen_NoBarFound));
var mapperMock = new Mock <IDtoMapper <Bar, BarDto> >();
var searchMapperMock = new Mock <IDtoMapper <Bar, SearchBarDto> >();
var cocktailMapperMock = new Mock <IDtoMapper <Cocktail, CocktailDto> >();
var guid = Guid.NewGuid();
using (var assertContext = new CWContext(options))
{
//Act & Assert
var sut = new BarService(assertContext, mapperMock.Object, searchMapperMock.Object, cocktailMapperMock.Object);
await Assert.ThrowsExceptionAsync <BusinessLogicException>(() => sut.DeleteAsync(guid));
}
}
public async Task ReturnInstanceOfTypeIngredientDto()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(ReturnInstanceOfTypeIngredientDto));
var mapperMock = new Mock <IDtoMapper <Ingredient, IngredientDto> >();
using (var assertContext = new CWContext(options))
{
//Act & Assert
var sut = new IngredientService(assertContext, mapperMock.Object);
var result = await sut.CreateIngredientAsync("djodjan");
Assert.IsInstanceOfType(result, typeof(Ingredient));
Assert.AreEqual("djodjan", result.Name);
}
}
public void CocktailRatingServiceConstructor_CreatesInstance()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(CocktailRatingServiceConstructor_CreatesInstance));
var mapperMock = new Mock <IDtoMapper <CocktailRating, CocktailRatingDto> >();
using (var assertContext = new CWContext(options))
{
//Act
var sut = new CocktailRatingService(assertContext, mapperMock.Object);
//Assert
Assert.IsNotNull(sut);
}
}
public async Task ThrowWhen_DtoPassedIsNull()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(ThrowWhen_DtoPassedIsNull));
var mapperMock = new Mock <IDtoMapper <CocktailRating, CocktailRatingDto> >();
mapperMock.Setup(x => x.MapFrom(It.IsAny <CocktailRating>())).Returns(It.IsAny <CocktailRatingDto>);
using (var assertContext = new CWContext(options))
{
//Act & Assert
var sut = new CocktailRatingService(assertContext, mapperMock.Object);
await Assert.ThrowsExceptionAsync <BusinessLogicException>(() => sut.CreateAsync(null));
}
}
public async Task ThrowWhen_CocktailIsNull()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(ThrowWhen_CocktailIsNull));
var mapperMock = new Mock <IDtoMapper <Cocktail, CocktailDto> >();
var barMapperMock = new Mock <IDtoMapper <Bar, BarDto> >();
var cocktailDetailsMapperMock = new Mock <IDtoMapper <Cocktail, DetailsCocktailDto> >();
var ingredientMapperMock = new Mock <IDtoMapper <Ingredient, IngredientDto> >();
var ingredientServiceMock = new Mock <IIngredientService>();
var cocktailIngredientServiceMock = new Mock <ICocktailIngredientService>();
var testGuid = Guid.NewGuid();
var testGuid2 = Guid.NewGuid();
var cocktail = new Cocktail
{
Id = testGuid,
Name = "TestOneName",
ImagePath = "ImagePathOne"
};
var cocktailDto = new CocktailDto
{
Id = testGuid,
Name = "TestOneName",
ImagePath = "ImagePathOne"
};
mapperMock.Setup(x => x.MapFrom(It.IsAny <Cocktail>())).Returns(cocktailDto);
using (var arrangeContext = new CWContext(options))
{
await arrangeContext.Cocktails.AddAsync(cocktail);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new CWContext(options))
{
//Act & Assert
var sut = new CocktailService(assertContext, mapperMock.Object, barMapperMock.Object, cocktailDetailsMapperMock.Object,
ingredientServiceMock.Object, cocktailIngredientServiceMock.Object);
await Assert.ThrowsExceptionAsync <BusinessLogicException>(() => sut.GetCocktailBarsAsync(testGuid2));
}
}
public async Task ThrowWhen_NoCommentFound()
{
// Arrange
var options = TestUtilities.GetOptions(nameof(ThrowWhen_NoCommentFound));
var mapperMock = new Mock <IDtoMapper <BarComment, BarCommentDto> >();
var id = Guid.NewGuid();
var barId = Guid.NewGuid();
using (var assertContext = new CWContext(options))
{
//Act & Assert
var sut = new BarCommentService(assertContext, mapperMock.Object);
await Assert.ThrowsExceptionAsync <BusinessLogicException>(() => sut.DeleteAsync(id, barId));
}
}
public async Task ReturnCorrectTypeOfInstance_WhenParamIsActive()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(ReturnCorrectTypeOfInstance_WhenParamIsActive));
var mapperMock = new Mock <IDtoMapper <User, UserDto> >();
var testGuid = Guid.NewGuid();
var testGuid2 = Guid.NewGuid();
var users = new List <User>
{
new User {
Id = testGuid, UserName = "******", IsBanned = false
},
new User {
Id = testGuid2, UserName = "******", IsBanned = false
},
};
var userDtos = new List <UserDto>
{
new UserDto {
Id = testGuid, UserName = "******", IsBanned = false
},
new UserDto {
Id = testGuid2, UserName = "******", IsBanned = false
},
};
mapperMock.Setup(u => u.MapFrom(It.IsAny <ICollection <User> >())).Returns(userDtos);
using (var actContext = new CWContext(options))
{
//Act & Assert
var sut = new BanService(actContext, mapperMock.Object);
await actContext.Users.AddAsync(users[0]);
await actContext.Users.AddAsync(users[1]);
await actContext.SaveChangesAsync();
var result = await sut.GetAllAsync("active");
Assert.IsInstanceOfType(result, typeof(ICollection <UserDto>));
}
}
public void BarServiceConstructor_CreatesInstance()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(BarServiceConstructor_CreatesInstance));
var mapperMock = new Mock <IDtoMapper <Bar, BarDto> >();
var searchMapperMock = new Mock <IDtoMapper <Bar, SearchBarDto> >();
var cocktailMapperMock = new Mock <IDtoMapper <Cocktail, CocktailDto> >();
using (var assertContext = new CWContext(options))
{
//Act
var sut = new BarService(assertContext, mapperMock.Object, searchMapperMock.Object, cocktailMapperMock.Object);
//Assert
Assert.IsNotNull(sut);
}
}
static async Task FillCourses()
{
var udemy = new UdemyScraper();
var courses = new List <Course>();
await foreach (var slice in udemy.GetCoursesAsync())
{
courses.AddRange(slice);
}
courses = courses.GroupBy(c => c.ID).Select(g => g.First()).ToList();
using var db = new CWContext();
await db.Courses.AddRangeAsync(courses);
await db.SaveChangesAsync();
}
public async Task ThrowWhen_NoBarsFound()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(ThrowWhen_NoBarsFound));
var mapperMock = new Mock <IDtoMapper <Bar, BarDto> >();
var searchMapperMock = new Mock <IDtoMapper <Bar, SearchBarDto> >();
var cocktailMapperMock = new Mock <IDtoMapper <Cocktail, CocktailDto> >();
mapperMock.Setup(x => x.MapFrom(It.IsAny <ICollection <Bar> >())).Returns(It.IsAny <ICollection <BarDto> >);
using (var assertContext = new CWContext(options))
{
//Act & Assert
var sut = new BarService(assertContext, mapperMock.Object, searchMapperMock.Object, cocktailMapperMock.Object);
await Assert.ThrowsExceptionAsync <BusinessLogicException>(() => sut.GetTopBarsAsync(1));
}
}
public async Task CorrectlyDeleteCocktail()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(CorrectlyDeleteCocktail));
var mapperMock = new Mock <IDtoMapper <Cocktail, CocktailDto> >();
var barMapperMock = new Mock <IDtoMapper <Bar, BarDto> >();
var cocktailDetailsMapperMock = new Mock <IDtoMapper <Cocktail, DetailsCocktailDto> >();
var ingredientMapperMock = new Mock <IDtoMapper <Ingredient, IngredientDto> >();
var ingredientServiceMock = new Mock <IIngredientService>();
var cocktailIngredientServiceMock = new Mock <ICocktailIngredientService>();
var testGuid = Guid.NewGuid();
var cocktail = new Cocktail
{
Id = testGuid,
Name = "TestOneName",
ImagePath = "ImagePathOne"
};
using (var actContext = new CWContext(options))
{
//Act
await actContext.Cocktails.AddAsync(cocktail);
await actContext.SaveChangesAsync();
var service = new CocktailService(actContext, mapperMock.Object, barMapperMock.Object, cocktailDetailsMapperMock.Object,
ingredientServiceMock.Object, cocktailIngredientServiceMock.Object);
var result = await service.DeleteAsync(testGuid);
await actContext.SaveChangesAsync();
}
using (var assertContext = new CWContext(options))
{
//Assert
var result = await assertContext.Cocktails.FirstAsync();
Assert.AreEqual(true, result.IsDeleted);
}
}
public async Task ThrowWhen_IngredientIsUsedInCocktails()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(ThrowWhen_IngredientIsUsedInCocktails));
var mapperMock = new Mock <IDtoMapper <Ingredient, IngredientDto> >();
var ingTestGuid = Guid.NewGuid();
var cocktailTestGuid = Guid.NewGuid();
var ingredient = new Ingredient
{
Id = ingTestGuid,
Name = "djodjan",
IsDeleted = false,
};
var cocktail = new Cocktail
{
Id = cocktailTestGuid,
Name = "test"
};
var cocktailIngr = new CocktailIngredient
{
CocktailId = cocktail.Id,
IngredientId = ingredient.Id,
};
using (var arrangeContext = new CWContext(options))
{
await arrangeContext.Ingredients.AddAsync(ingredient);
await arrangeContext.Cocktails.AddAsync(cocktail);
await arrangeContext.CocktailIngredients.AddAsync(cocktailIngr);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new CWContext(options))
{
//Act & Assert
var sut = new IngredientService(assertContext, mapperMock.Object);
await Assert.ThrowsExceptionAsync <BusinessLogicException>(() => sut.DeleteAsync(ingredient.Id));
}
}
public async Task CorrectlyUpdateEntity()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(CorrectlyUpdateEntity));
var mapperMock = new Mock <IDtoMapper <Cocktail, CocktailDto> >();
var barMapperMock = new Mock <IDtoMapper <Bar, BarDto> >();
var cocktailDetailsMapperMock = new Mock <IDtoMapper <Cocktail, DetailsCocktailDto> >();
var ingredientMapperMock = new Mock <IDtoMapper <Ingredient, IngredientDto> >();
var ingredientServiceMock = new Mock <IIngredientService>();
var cocktailIngredientServiceMock = new Mock <ICocktailIngredientService>();
var testGuid = Guid.NewGuid();
var cocktail = new Cocktail
{
Id = testGuid,
Name = "TestOneName",
ImagePath = "ImagePathOne",
Info = "Info"
};
using (var arrangeContext = new CWContext(options))
{
await arrangeContext.Cocktails.AddAsync(cocktail);
await arrangeContext.SaveChangesAsync();
}
mapperMock.Setup(x => x.MapFrom(It.IsAny <Cocktail>())).Returns(It.IsAny <CocktailDto>);
using (var assertContext = new CWContext(options))
{
var sut = new CocktailService(assertContext, mapperMock.Object, barMapperMock.Object, cocktailDetailsMapperMock.Object,
ingredientServiceMock.Object, cocktailIngredientServiceMock.Object);
var result = await sut.EditAsync(testGuid, "newTestName", "newTestInfo");
var edittedCocktail = await assertContext.Cocktails.FirstAsync();
Assert.AreEqual("newTestName", edittedCocktail.Name);
Assert.AreEqual("newTestInfo", edittedCocktail.Info);
}
}
public async Task Throw_WhenNoBarRatingDtoFound()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(Throw_WhenNoBarRatingDtoFound));
var mapperMock = new Mock <IDtoMapper <BarRating, BarRatingDto> >();
var barId = Guid.NewGuid();
var userId = Guid.NewGuid();
var userIdTwo = Guid.NewGuid();
var entity = new BarRating
{
BarId = barId,
UserId = userId,
Value = 2
};
var entityDto = new BarRatingDto
{
BarId = barId,
UserId = userId,
Value = 2
};
mapperMock.Setup(x => x.MapFrom(It.IsAny <BarRating>())).Returns(entityDto);
using (var arrangeContext = new CWContext(options))
{
await arrangeContext.BarRatings.AddAsync(entity);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new CWContext(options))
{
//Act & Assert
var sut = new BarRatingService(assertContext, mapperMock.Object);
await Assert.ThrowsExceptionAsync <BusinessLogicException>(() => sut.GetRatingAsync(barId, userId));
}
}
public async Task ReturnCorrectTypeOfEntity()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(ReturnCorrectTypeOfEntity));
var mapperMock = new Mock <IDtoMapper <Bar, BarDto> >();
var searchMapperMock = new Mock <IDtoMapper <Bar, SearchBarDto> >();
var cocktailMapperMock = new Mock <IDtoMapper <Cocktail, CocktailDto> >();
var testGuid = Guid.NewGuid();
var bar = new Bar
{
Id = testGuid,
Name = "testBar",
Info = "testInfo",
Address = "testAddress",
Phone = "111-333-666",
};
var dtoEntity = new BarDto
{
Id = testGuid,
Name = "testBar",
Info = "testInfo",
Address = "testAddress",
Phone = "111-333-666"
};
mapperMock.Setup(x => x.MapFrom(It.IsAny <Bar>())).Returns(dtoEntity);
using (var arrangeContext = new CWContext(options))
{
await arrangeContext.Bars.AddAsync(bar);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new CWContext(options))
{
var sut = new BarService(assertContext, mapperMock.Object, searchMapperMock.Object, cocktailMapperMock.Object);
var result = await sut.EditAsync(testGuid, "newTestName", "newTestInfo", "newTestAddress", "111-333-6667");
Assert.IsInstanceOfType(result, typeof(BarDto));
}
}
public void Throw_WhenBarMapperIsNull()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(Throw_WhenBarMapperIsNull));
var mapperMock = new Mock <IDtoMapper <Cocktail, CocktailDto> >();
var barMapperMock = new Mock <IDtoMapper <Bar, BarDto> >();
var cocktailDetailsMapperMock = new Mock <IDtoMapper <Cocktail, DetailsCocktailDto> >();
var ingredientServiceMock = new Mock <IIngredientService>();
var cocktailIngredientServiceMock = new Mock <ICocktailIngredientService>();
using (var assertContext = new CWContext(options))
{
//Act & Assert
Assert.ThrowsException <ArgumentNullException>(() => new CocktailService(assertContext, mapperMock.Object, null,
cocktailDetailsMapperMock.Object, ingredientServiceMock.Object, cocktailIngredientServiceMock.Object));
}
}
public async Task CorrectlyUpdateEntity()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(CorrectlyUpdateEntity));
var mapperMock = new Mock <IDtoMapper <CocktailComment, CocktailCommentDto> >();
var id = Guid.NewGuid();
var cocktailId = Guid.NewGuid();
var userId = Guid.NewGuid();
var createdOn = DateTime.UtcNow;
var entity = new CocktailComment
{
Id = id,
CocktailId = cocktailId,
UserId = userId,
Body = "testbody",
CreatedOn = createdOn
};
using (var arrangeContext = new CWContext(options))
{
await arrangeContext.CocktailComments.AddAsync(entity);
await arrangeContext.SaveChangesAsync();
}
mapperMock.Setup(x => x.MapFrom(It.IsAny <CocktailComment>())).Returns(It.IsAny <CocktailCommentDto>);
using (var assertContext = new CWContext(options))
{
var sut = new CocktailCommentService(assertContext, mapperMock.Object);
var result = await sut.EditAsync(id, "newbody");
var modifiedComment = await assertContext.CocktailComments.FirstAsync();
Assert.AreEqual("newbody", modifiedComment.Body);
}
}
public async Task CorrectlyRemoveBan_WhenParamsAreValid()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(CorrectlyRemoveBan_WhenParamsAreValid));
var mapperMock = new Mock <IDtoMapper <User, UserDto> >();
var testGuid = Guid.NewGuid();
var userTest = new User {
Id = testGuid, UserName = "******", IsBanned = true, LockoutEnabled = true, LockoutEnd = DateTime.UtcNow.AddDays(1)
};
var banTest = new Ban {
HasExpired = false, User = userTest
};
using (var actContext = new CWContext(options))
{
//Act
await actContext.Users.AddAsync(userTest);
await actContext.Bans.AddAsync(banTest);
await actContext.SaveChangesAsync();
var sut = new BanService(actContext, mapperMock.Object);
await sut.RemoveAsync(testGuid);
await actContext.SaveChangesAsync();
}
using (var assertContext = new CWContext(options))
{
//Assert
var user = await assertContext.Users.FirstAsync();
var ban = assertContext.Bans
.Include(u => u.User)
.Where(b => b.User == user)
.FirstOrDefault();
Assert.AreEqual(user.IsBanned, false);
Assert.AreEqual(ban.HasExpired, true);
Assert.AreEqual(user.LockoutEnd < DateTime.Now, true);
}
}
public async Task ThrowWhen_NoCommentFound()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(ThrowWhen_NoCommentFound));
var mapperMock = new Mock <IDtoMapper <BarComment, BarCommentDto> >();
var id = Guid.NewGuid();
var barId = Guid.NewGuid();
var userId = Guid.NewGuid();
var fakeId = Guid.NewGuid();
var createdOn = DateTime.UtcNow;
var entity = new BarComment
{
Id = id,
BarId = barId,
UserId = userId,
Body = "testbody",
CreatedOn = createdOn
};
mapperMock.Setup(x => x.MapFrom(It.IsAny <BarComment>())).Returns(It.IsAny <BarCommentDto>);
using (var arrangeContext = new CWContext(options))
{
await arrangeContext.BarComments.AddAsync(entity);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new CWContext(options))
{
//Act & Assert
var sut = new BarCommentService(assertContext, mapperMock.Object);
await Assert.ThrowsExceptionAsync <BusinessLogicException>(() => sut.EditAsync(fakeId, "newbody"));
}
}
public async Task ThrowWhen_NoBanIsFound()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(CorrectlyRemoveBan_WhenParamsAreValid));
var mapperMock = new Mock <IDtoMapper <User, UserDto> >();
var testGuid = Guid.NewGuid();
var userTest = new User {
Id = testGuid, UserName = "******", IsBanned = true, LockoutEnabled = true, LockoutEnd = DateTime.UtcNow.AddDays(1)
};
using (var assertContext = new CWContext(options))
{
//Act & Assert
await assertContext.Users.AddAsync(userTest);
await assertContext.SaveChangesAsync();
var sut = new BanService(assertContext, mapperMock.Object);
await Assert.ThrowsExceptionAsync <BusinessLogicException>(() => sut.RemoveAsync(testGuid));
}
}
public async Task SetCorrectParam_WhenValueIsValid()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(SetCorrectParam_WhenValueIsValid));
var mapperMock = new Mock <IDtoMapper <Ingredient, IngredientDto> >();
var testGuid = Guid.NewGuid();
var entity = new Ingredient
{
Id = testGuid,
Name = "djodjan",
IsDeleted = false
};
var ingredientDto = new IngredientDto
{
Id = testGuid,
Name = "djodjan",
};
mapperMock.Setup(x => x.MapFrom(It.IsAny <Ingredient>())).Returns(ingredientDto);
using (var arrangeContext = new CWContext(options))
{
await arrangeContext.Ingredients.AddAsync(entity);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new CWContext(options))
{
//Act & Assert
var sut = new IngredientService(assertContext, mapperMock.Object);
var result = await sut.EditAsync(testGuid, "newDjodjan");
var ingredient = await assertContext.Ingredients.FirstAsync();
Assert.AreEqual("newDjodjan", ingredient.Name);
}
}
public async Task ReturnCorrectDtoWhen_ParamsAreValid()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(ReturnCorrectDtoWhen_ParamsAreValid));
var mapperMock = new Mock <IDtoMapper <Bar, BarDto> >();
var searchMapperMock = new Mock <IDtoMapper <Bar, SearchBarDto> >();
var cocktailMapperMock = new Mock <IDtoMapper <Cocktail, CocktailDto> >();
var testGuid = Guid.NewGuid();
var bar1 = new Bar
{
Id = testGuid,
Name = "testBar1",
};
var barDto1 = new BarDto
{
Id = testGuid,
Name = "testBar1",
};
mapperMock.Setup(x => x.MapFrom(It.IsAny <Bar>())).Returns(barDto1);
using (var arrangeContext = new CWContext(options))
{
await arrangeContext.Bars.AddAsync(bar1);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new CWContext(options))
{
//Act & Assert
var sut = new BarService(assertContext, mapperMock.Object, searchMapperMock.Object, cocktailMapperMock.Object);
var result = await sut.GetBarCocktailsAsync(testGuid);
Assert.IsInstanceOfType(result, typeof(BarDto));
Assert.AreEqual("testBar1", result.Name);
}
}
public async Task CorrectlyUpdateEntity()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(CorrectlyUpdateEntity));
var mapperMock = new Mock <IDtoMapper <Bar, BarDto> >();
var searchMapperMock = new Mock <IDtoMapper <Bar, SearchBarDto> >();
var cocktailMapperMock = new Mock <IDtoMapper <Cocktail, CocktailDto> >();
var testGuid = Guid.NewGuid();
var bar = new Bar
{
Id = testGuid,
Name = "testBar",
Info = "testInfo",
Address = "testAddress",
Phone = "111-333-666",
};
using (var arrangeContext = new CWContext(options))
{
await arrangeContext.Bars.AddAsync(bar);
await arrangeContext.SaveChangesAsync();
}
mapperMock.Setup(x => x.MapFrom(It.IsAny <Bar>())).Returns(It.IsAny <BarDto>);
using (var assertContext = new CWContext(options))
{
var sut = new BarService(assertContext, mapperMock.Object, searchMapperMock.Object, cocktailMapperMock.Object);
var result = await sut.EditAsync(testGuid, "newTestName", "newTestInfo", "newTestAddress", "111-333-6667");
var edittedBar = await assertContext.Bars.FirstAsync();
Assert.AreEqual("newTestName", edittedBar.Name);
Assert.AreEqual("newTestInfo", edittedBar.Info);
Assert.AreEqual("newTestAddress", edittedBar.Address);
Assert.AreEqual("111-333-6667", edittedBar.Phone);
}
}
public async Task ReturnCorrectType_ValidValueIsPassed()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(ReturnCorrectCountWhen_ValidValueIsPassed));
var mapperMock = new Mock <IDtoMapper <Bar, BarDto> >();
var searchMapperMock = new Mock <IDtoMapper <Bar, SearchBarDto> >();
var cocktailMapperMock = new Mock <IDtoMapper <Cocktail, CocktailDto> >();
var testGuid = Guid.NewGuid();
var testGuid2 = Guid.NewGuid();
var bar1 = new Bar
{
Id = testGuid,
Name = "testBar1",
};
var bar2 = new Bar
{
Id = testGuid2,
Name = "testBar2",
};
using (var arrangeContext = new CWContext(options))
{
await arrangeContext.Bars.AddAsync(bar1);
await arrangeContext.Bars.AddAsync(bar2);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new CWContext(options))
{
//Act & Assert
var sut = new BarService(assertContext, mapperMock.Object, searchMapperMock.Object, cocktailMapperMock.Object);
var result = await sut.GetPageCountAsync(10);
Assert.IsInstanceOfType(result, typeof(int));
}
}
public void CocktailServiceConstructor_CreatesInstance()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(CocktailServiceConstructor_CreatesInstance));
var mapperMock = new Mock <IDtoMapper <Cocktail, CocktailDto> >();
var barMapperMock = new Mock <IDtoMapper <Bar, BarDto> >();
var cocktailDetailsMapperMock = new Mock <IDtoMapper <Cocktail, DetailsCocktailDto> >();
var ingredientServiceMock = new Mock <IIngredientService>();
var cocktailIngredientServiceMock = new Mock <ICocktailIngredientService>();
using (var assertContext = new CWContext(options))
{
//Act
var sut = new CocktailService(assertContext, mapperMock.Object, barMapperMock.Object,
cocktailDetailsMapperMock.Object, ingredientServiceMock.Object, cocktailIngredientServiceMock.Object);
//Assert
Assert.IsNotNull(sut);
}
}
public async Task CorrectlyCreateBar()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(CorrectlyCreateBar));
var mapperMock = new Mock <IDtoMapper <Bar, BarDto> >();
var searchMapperMock = new Mock <IDtoMapper <Bar, SearchBarDto> >();
var cocktailMapperMock = new Mock <IDtoMapper <Cocktail, CocktailDto> >();
var entityDto = new BarDto
{
Id = Guid.NewGuid(),
Name = "testBar",
Info = "testInfo",
Address = "testAddress",
ImagePath = "testImagePath",
Phone = "111-333-666"
};
mapperMock.Setup(x => x.MapFrom(It.IsAny <Bar>())).Returns(entityDto);
using (var assertContext = new CWContext(options))
{
//Act & Assert
var sut = new BarService(assertContext, mapperMock.Object, searchMapperMock.Object, cocktailMapperMock.Object);
var result = await sut.CreateAsync(entityDto);
Assert.IsInstanceOfType(result, typeof(BarDto));
Assert.AreEqual("testBar", result.Name);
Assert.AreEqual("testInfo", result.Info);
Assert.AreEqual("testAddress", result.Address);
Assert.AreEqual("testImagePath", result.ImagePath);
Assert.AreEqual("111-333-666", result.Phone);
Assert.AreEqual(entityDto.Name, result.Name);
Assert.AreEqual(entityDto.Info, result.Info);
Assert.AreEqual(entityDto.Address, result.Address);
Assert.AreEqual(entityDto.ImagePath, result.ImagePath);
Assert.AreEqual(entityDto.Phone, result.Phone);
}
}
public async Task CorrectlyDeleteBar()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(CorrectlyDeleteBar));
var mapperMock = new Mock <IDtoMapper <Bar, BarDto> >();
var searchMapperMock = new Mock <IDtoMapper <Bar, SearchBarDto> >();
var cocktailMapperMock = new Mock <IDtoMapper <Cocktail, CocktailDto> >();
var guid = Guid.NewGuid();
var entity = new Bar
{
Id = guid,
Name = "testBar",
Info = "testInfo",
Address = "testAddress",
ImagePath = "testImagePath",
Phone = "111-333-666"
};
using (var actContext = new CWContext(options))
{
//Act
await actContext.Bars.AddAsync(entity);
await actContext.SaveChangesAsync();
var service = new BarService(actContext, mapperMock.Object, searchMapperMock.Object, cocktailMapperMock.Object);
var result = await service.DeleteAsync(guid);
await actContext.SaveChangesAsync();
}
using (var assertContext = new CWContext(options))
{
//Assert
var result = await assertContext.Bars.FirstAsync();
Assert.AreEqual(true, result.IsDeleted);
}
}
public async Task ReturnInstanceOfTypeIngredientDto()
{
//Arrange
var options = TestUtilities.GetOptions(nameof(ReturnInstanceOfTypeIngredientDto));
var mapperMock = new Mock <IDtoMapper <Ingredient, IngredientDto> >();
var testGuid = new Guid("b9653c65-2311-4d57-a95b-6522d7bc88f6");
var entity = new Ingredient
{
Id = testGuid,
Name = "djodjan6",
IsDeleted = false
};
var ingredientDto = new IngredientDto
{
Id = testGuid,
Name = "djodjan",
};
mapperMock.Setup(x => x.MapFrom(It.IsAny <Ingredient>())).Returns(ingredientDto);
using (var actContext = new CWContext(options))
{
//Act
await actContext.Ingredients.AddAsync(entity);
await actContext.SaveChangesAsync();
}
using (var assertContext = new CWContext(options))
{
//Assert
var sut = new IngredientService(assertContext, mapperMock.Object);
var ingredient = await sut.GetIngredientAsync(testGuid);
Assert.IsInstanceOfType(ingredient, typeof(IngredientDto));
}
}
