public async Task ThrowExceptionForCocktailLike_WhenUserLikeExists()
{
var options = TestUtils.GetOptions(nameof(ThrowExceptionForCocktailLike_WhenUserLikeExists));
var bar = new Bar {
Id = "2"
};
var user = new AppUser {
Id = "1"
};
var review1 = new BarReview {
Id = "1", Rating = 6, Description = "0100101", BarId = "2"
};
//var review2 = new BarReview { Id = "2", Rating = 10, Description = "0100101", BarId = "2" };
var like1 = new BarReviewLike {
Id = "1", BarReviewID = "1", AppUserID = "1"
};
//var like2 = new BarReviewLike { Id = "2", BarReviewID = "2", AppUserID="1" };
using (var arrangeContext = new CMContext(options))
{
var sut = new ReviewServices(arrangeContext);
arrangeContext.Add(bar);
arrangeContext.Add(user);
arrangeContext.Add(review1);
//arrangeContext.Add(review2);
arrangeContext.Add(like1);
await arrangeContext.SaveChangesAsync();
await sut.LikeBarReview(bar.Id, user.Id);
var ex = await Assert.ThrowsExceptionAsync <MagicException>(
async() => await sut.LikeBarReview(bar.Id, review1.Id)
);
Assert.AreEqual(ExceptionMessages.ReviewIsLiked, ex.Message);
}
}
public async Task Throw_CorrectMagicExeption_NullValueIdPassed()
{
var options = TestUtils.GetOptions(nameof(Throw_CorrectMagicExeption_NullValueIdPassed));
var userStoreMocked = new Mock <IUserStore <AppUser> >();
var userManagerMocked =
new Mock <UserManager <AppUser> >
(userStoreMocked.Object, null, null, null, null, null, null, null, null);
using (var arrangeContext = new CMContext(options))
{
//1
arrangeContext.Users.Add(new AppUser {
Id = "1", UserName = "******"
});
//2
arrangeContext.Users.Add(new AppUser {
Id = "2", UserName = "******"
});
//3
arrangeContext.Users.Add(new AppUser {
Id = "3", UserName = "******"
});
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new CMContext(options))
{
var sut = new AppUserServices(assertContext, userManagerMocked.Object);
var result = await Assert.ThrowsExceptionAsync <MagicException>
(async() => await sut.GetUserByID(null));
Assert.AreEqual("ID cannot be null!", result.Message);
}
}
public async Task Calls_BarFactory_CreateNewBar_AtLeastOnce_WhenValidValuesArePassed()
{
var options = TestUtilities.GetOptions(nameof(Calls_BarFactory_CreateNewBar_AtLeastOnce_WhenValidValuesArePassed));
var barTest = new Bar()
{
Address = "Borisov 3",
Information = "Information",
MapDirections = "North",
Name = "Kobrat",
Picture = "Picture",
Rating = 4.5d
};
barFactoryMoq.Setup(bf => bf.CreateNewBar(barTest.Name, barTest.Address, barTest.Information, barTest.Picture, barTest.MapDirections)).Returns(barTest);
using (var assertContext = new CMContext(options))
{
var sut = new BarManager(assertContext, cocktailManagerMoq.Object, barFactoryMoq.Object);
await sut.CreateBar(barTest.ToDTO());
barFactoryMoq.Verify(bf => bf.CreateNewBar(barTest.Name, barTest.Address, barTest.Information, barTest.Picture, barTest.MapDirections), Times.Once);
}
}
public async Task AddBar_ToDatabase_WhenValidValuesPassed()
{
var options = TestUtilities.GetOptions(nameof(AddBar_ToDatabase_WhenValidValuesPassed));
var barTest = new Bar()
{
Address = "Borisov",
Information = "Information",
MapDirections = "North",
Name = "Bar",
Picture = "Picture",
Rating = 4.5d
};
barFactoryMoq.Setup(bf => bf.CreateNewBar(barTest.Name, barTest.Address, barTest.Information, barTest.Picture, barTest.MapDirections)).Returns(barTest);
using (var assertContext = new CMContext(options))
{
var sut = new BarManager(assertContext, cocktailManagerMoq.Object, barFactoryMoq.Object);
await sut.CreateBar(barTest.ToDTO());
Assert.AreEqual(1, assertContext.Bars.Count());
}
}
public async Task AddBarToDb_WithValidDtoParams()
{
var options = TestUtils.GetOptions(nameof(AddBarToDb_WithValidDtoParams));
var fileService = new Mock <IFileUploadService>();
using (var assertContext = new CMContext(options))
{
var sut = new BarServices(assertContext, fileService.Object);
var result = await sut.AddBarAsync(
new BarDTO
{
Id = barId,
Name = barName,
Website = barWebsite,
BarImage = new Mock <IFormFile>().Object,
});
Assert.AreEqual(barName, assertContext.Bars.First().Name);
Assert.AreEqual(barWebsite, assertContext.Bars.First().Website);
Assert.AreEqual(barId, assertContext.Bars.First().Id);
}
}
public async Task InvokeUploadImageMethod_WhenBarDtoImageIsValid()
{
var options = TestUtils.GetOptions(nameof(InvokeUploadImageMethod_WhenBarDtoImageIsValid));
var fileService = new Mock <IFileUploadService>();
using (var assertContext = new CMContext(options))
{
var sut = new BarServices(assertContext, fileService.Object);
var barDto =
new BarDTO
{
Id = barId,
Name = barName,
ImageUrl = "abv.bg",
Website = barWebsite,
BarImage = new Mock <IFormFile>().Object,
};
await sut.AddBarAsync(barDto);
fileService.Verify(x => x.SetUniqueImagePathForBar(barDto.BarImage), Times.AtLeastOnce);
}
}
public async Task SetDefaultImage_WhenBarDtoImagePathIsNull()
{
var options = TestUtils.GetOptions(nameof(SetDefaultImage_WhenBarDtoImagePathIsNull));
var file = new Mock <IFormFile>().Object;
var fileService = new Mock <IFileUploadService>();
fileService.Setup(f => f.SetUniqueImagePathForBar(null)).Returns("/images/defaultBarImage.jpg");
using (var assertContext = new CMContext(options))
{
var expectedPath = "/images/defaultBarImage.jpg";
var sut = new BarServices(assertContext, fileService.Object);
var result = await sut.AddBarAsync(
new BarDTO
{
Id = barId,
Name = barName,
Website = barWebsite,
});
Assert.AreEqual(expectedPath, assertContext.Bars.First().Image);
}
}
public async Task ReturnObjectOfTheCorrectType_WhenValidIdIsPassed()
{
var options = TestUtils.GetOptions(nameof(ReturnObjectOfTheCorrectType_WhenValidIdIsPassed));
var cocktailId = "15";
var newCocktail = new Cocktail()
{
Id = cocktailId
};
using (var arrangeContext = new CMContext(options))
{
arrangeContext.Add(newCocktail);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new CMContext(options))
{
var sut = new CocktailServices(assertContext, _fileUploadService.Object,
_ingredientServices.Object, _recipeServices.Object);
var result = await sut.FindCocktailById(cocktailId);
Assert.IsInstanceOfType(result, typeof(CocktailDto));
}
}
public async Task ThrowException_WhenTheCocktailIsDeleted()
{
var options = TestUtils.GetOptions(nameof(ThrowException_WhenTheCocktailIsDeleted));
var cocktailId = "15";
var cocktailName = "Mohito";
var newCocktail = new Cocktail()
{
Id = cocktailId, Name = cocktailName, DateDeleted = DateTime.Now
};
using (var arrangeContext = new CMContext(options))
{
arrangeContext.Add(newCocktail);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new CMContext(options))
{
var sut = new CocktailServices(assertContext, _fileUploadService.Object,
_ingredientServices.Object, _recipeServices.Object);
var ex = await Assert.ThrowsExceptionAsync <MagicException>(
async() => await sut.GetCocktailIdByName(cocktailName));
}
}
public async Task GetCountry_Throws_When_NameNotFound()
{
//Arrange
var options = Utils.GetOptions(nameof(GetCountry_Throws_When_NameNotFound));
var country = new Country {
Id = Guid.NewGuid(), Name = "Bulgaria", IsDeleted = true
};
using (var arrangeContext = new CMContext(options))
{
await arrangeContext.Countries.AddAsync(country);
await arrangeContext.SaveChangesAsync();
}
//Act, Assert
using (var assertContext = new CMContext(options))
{
var sut = new CountryServices(assertContext);
await Assert.ThrowsExceptionAsync <ArgumentNullException>(() => sut.GetCountry("Japan"));
}
}
public async Task GetMax5SortedCocktails_WhenCalled()
{
var options = TestUtils.GetOptions(nameof(GetMax5SortedCocktails_WhenCalled));
var sortOrder = "name_desc";
using (var arrangeContext = new CMContext(options))
{
for (int i = 0; i < 10; i++)
{
arrangeContext.Add(new Cocktail());
}
;
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new CMContext(options))
{
var sut = new CocktailServices(assertContext, _fileUploadService.Object,
_ingredientServices.Object, _recipeServices.Object);
var result = await sut.GetFiveSortedCocktailsAsync(sortOrder);
Assert.AreEqual(5, result.Count);
}
}
public async Task Throw_When_Bar_IsMissing()
{
//Arrange
var options = Utils.GetOptions(nameof(Throw_When_Bar_IsMissing));
var barNameNew = "Bbb";
var barDTO = new BarDTO()
{
Id = Guid.Parse("92a05c62-6f33-4dc9-bcc1-c9c946bf693a"),
Name = barNameNew,
Phone = "0898878465",
CityId = Guid.Parse("cc44371d-594f-4c47-a82b-e606bede8d3b"), //Varna
Address = "62 Prof. Marin Drinov Str.",
};
//Act,Assert
using (var assertContext = new CMContext(options))
{
var sut = new BarService(assertContext);
await Assert.ThrowsExceptionAsync <ArgumentNullException>
(async() => await sut.UpdateBarAsync(barDTO));
}
}
public async Task GetCorrectCocktail_WhenValidIdIsPassed()
{
var options = TestUtils.GetOptions(nameof(GetCorrectCocktail_WhenValidIdIsPassed));
var cocktailId = "15";
var newCocktail = new Cocktail()
{
Id = cocktailId
};
using (var arrangeContext = new CMContext(options))
{
arrangeContext.Add(newCocktail);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new CMContext(options))
{
var sut = new CocktailServices(assertContext, _fileUploadService.Object,
_ingredientServices.Object, _recipeServices.Object);
var result = await sut.FindCocktailById(cocktailId);
Assert.AreEqual(cocktailId, result.Id);
}
}
public async Task ReturnCorrectTypeFor5Cocktails_WhenCalled()
{
var options = TestUtils.GetOptions(nameof(ReturnCorrectTypeFor5Cocktails_WhenCalled));
var sortOrder = "name_desc";
using (var arrangeContext = new CMContext(options))
{
for (int i = 0; i < 5; i++)
{
arrangeContext.Add(new Cocktail());
}
;
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new CMContext(options))
{
var sut = new CocktailServices(assertContext, _fileUploadService.Object,
_ingredientServices.Object, _recipeServices.Object);
var result = await sut.GetFiveSortedCocktailsAsync(sortOrder);
Assert.IsInstanceOfType(result, typeof(List <CocktailDto>));
}
}
public async Task Get_Correct_Ingredient()
{
var options = Utils.GetOptions(nameof(Get_Correct_Ingredient));
var ingredient = new Ingredient
{
Id = Guid.Parse("1b98e50e-8314-4b1e-82df-491c3c8d086f"),
Name = "Gin",
Abv = 40,
Description = "Gin is a distilled alcoholic drink that derives its " +
"predominant flavour from juniper berries (Juniperus communis). " +
"Gin is one of the broadest categories of spirits, all of various origins, styles," +
" and flavour profiles, that revolve around juniper as a common ingredient.",
TypeId = Guid.Parse("27309394-4ac3-4dc6-a81a-c8e147e378f0"),
Type = new IngredientType()
{
Id = Guid.Parse("27309394-4ac3-4dc6-a81a-c8e147e378f0"),
Name = "Burbon"
},
};
using (var arrangeContext = new CMContext(options))
{
arrangeContext.Ingredients.Add(ingredient);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new CMContext(options))
{
var sut = new IngredientService(assertContext);
Guid resultGuid = new Guid("1b98e50e-8314-4b1e-82df-491c3c8d086f");
var result = await sut.GetIngredient(resultGuid);
Assert.AreEqual("Gin", result.Name);
Assert.AreEqual(40, result.Abv);
Assert.IsInstanceOfType(result, typeof(IngredientDTO));
}
}
public async Task ReturnCorrectType_WhenCalledWithCorrectId()
{
var options = TestUtils.GetOptions(nameof(ReturnCorrectType_WhenCalledWithCorrectId));
var adminName = "pesho";
var id = "1";
var description = "new";
var userName = "******";
var notification = new Notification
{
Description = description,
Username = userName,
UserId = "1"
};
var admin = new AppUser
{
Id = id,
UserName = adminName
};
_userServices.Setup(x => x.GetAdmin())
.ReturnsAsync(admin);
using (var arrangeContext = new CMContext(options))
{
arrangeContext.Add(admin);
arrangeContext.Add(notification);
await arrangeContext.SaveChangesAsync();
var sut = new NotificationServices(arrangeContext, _userServices.Object,
_iNotificationManager.Object);
var result = await sut.GetNotificationsForUserAsync(id);
Assert.IsInstanceOfType(result, typeof(List <NotificationDTO>));
}
}
public async Task GetBar_Returns_Correct_When_Params_Are_Valid()
{
//Arrange
var options = Utils.GetOptions(nameof(GetBar_Returns_Correct_When_Params_Are_Valid));
var bar = new Bar
{
Id = Guid.Parse("cda3e6b5-c77c-4682-a7ff-73987919a059"),
Name = "Cosmos",
Address = "Sofia",
Rating = 2,
Country = new Country {
Name = "Bulgaria"
}
};
using (var arrangeContext = new CMContext(options))
{
await arrangeContext.Bars.AddAsync(bar);
await arrangeContext.SaveChangesAsync();
}
//Act, Assert
using (var assertContext = new CMContext(options))
{
var sut = new BarServices(assertContext);
var result = await sut.GetBar(bar.Id);
Assert.AreEqual(bar.Name, result.Name);
Assert.AreEqual(bar.Address, result.Address);
Assert.AreEqual(bar.Rating, result.Rating);
Assert.IsInstanceOfType(result, typeof(BarDTO));
}
}
public async Task Return_AnnonymousAsUserName_IfNullIdPassed()
{
var options = TestUtils.GetOptions(nameof(Return_AnnonymousAsUserName_IfNullIdPassed));
var userStoreMocked = new Mock <IUserStore <AppUser> >();
var userManagerMocked =
new Mock <UserManager <AppUser> >
(userStoreMocked.Object, null, null, null, null, null, null, null, null);
using (var arrangeContext = new CMContext(options))
{
//1
arrangeContext.Users.Add(new AppUser {
Id = "1", UserName = "******"
});
//2
arrangeContext.Users.Add(new AppUser {
Id = "2", UserName = "******"
});
//3
arrangeContext.Users.Add(new AppUser {
Id = "3", UserName = "******"
});
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new CMContext(options))
{
var sut = new AppUserServices(assertContext, userManagerMocked.Object);
var result = await sut.GetUsernameById(null);
Assert.AreEqual("annonymous", result);
}
}
public async Task CreateBar_Return_Correct_When_Params_AreValid()
{
//Arrange
var options = Utils.GetOptions(nameof(CreateBar_Return_Correct_When_Params_AreValid));
var country = new Country {
Id = Guid.Parse("295afbfe-5410-49db-b5b1-161b1ce8fd3c"), Name = "USA"
};
var bar = new BarDTO
{
Id = Guid.NewGuid(),
Name = "Cosmos",
CountryId = country.Id,
CountryName = country.Name
};
using (var arrangeContext = new CMContext(options))
{
await arrangeContext.Countries.AddAsync(country);
await arrangeContext.SaveChangesAsync();
}
//Act,Assert
using (var assertContext = new CMContext(options))
{
var sut = new BarServices(assertContext);
var result = await sut.CreateBar(bar);
Assert.AreEqual(1, assertContext.Bars.Count());
Assert.AreEqual(bar.Name, result.Name);
Assert.IsInstanceOfType(result, typeof(BarDTO));
}
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, CMContext context)
{
app.UpdateDatabase();
DataSeeder.SeedIngredients(context);
DataSeeder.SeedCocktails(context);
DataSeeder.SeedBars(context);
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
app.UseDatabaseErrorPage();
}
else
{
app.UseExceptionHandler("/Home/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseCookiePolicy();
app.UseMiddleware <PageNotFoundMiddleware>();
app.UseAuthentication();
app.UseMvc(routes =>
{
routes.MapRoute(
name: "area",
template: "{area:exists}/{controller=Home}/{action=Index}/{id?}");
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});
}
public async Task DeleteIngredient_Throws_When_IngredientNotFound()
{
//Arrange
var options = Utils.GetOptions(nameof(DeleteIngredient_Throws_When_IngredientNotFound));
var ingredient = new Ingredient {
Id = Guid.NewGuid(), Name = "Rum", Description = "Alcoholic spirit"
};
var id = Guid.NewGuid();
using (var arrangeContext = new CMContext(options))
{
await arrangeContext.Ingredients.AddAsync(ingredient);
await arrangeContext.SaveChangesAsync();
}
//Act, Assert
using (var assertContext = new CMContext(options))
{
var sut = new IngredientServices(assertContext);
await Assert.ThrowsExceptionAsync <ArgumentNullException>(() => sut.DeleteIngredient(id));
}
}
public async Task ThrowCorrectMagicExeption_IfUserRoleConnection_DoesnotExist()
{
var options = TestUtils.GetOptions(nameof(ThrowMagicExeption_IfUserRoleConnection_DoesnotExist));
var userStoreMocked = new Mock <IUserStore <AppUser> >();
var userManagerMocked =
new Mock <UserManager <AppUser> >
(userStoreMocked.Object, null, null, null, null, null, null, null, null);
using (var assertContext = new CMContext(options))
{
var role = new AppRole {
Name = "Administrator", NormalizedName = "ADMINISTRATOR"
};
assertContext.Roles.Add(role);
await assertContext.SaveChangesAsync();
var sut = new AppUserServices(assertContext, userManagerMocked.Object);
var ex = await Assert.ThrowsExceptionAsync <MagicException>
(async() => await sut.GetAdmin());
Assert.AreEqual("UserRole cannot be null!", ex.Message);
}
}
public async Task ThrowException_WhenUserCocktailLikeExists()
{
var options = TestUtils.GetOptions(nameof(ThrowException_WhenUserCocktailLikeExists));
var cocktail = new Cocktail {
Id = "2"
};
var user = new AppUser {
Id = "1"
};
var review1 = new CocktailReview {
Id = "1", Rating = 6, Description = "0100101", UserId = user.Id, CocktailId = "2"
};
var review2 = new CocktailReview {
Id = "2", Rating = 10, Description = "0100101", UserId = user.Id, CocktailId = "2"
};
var like1 = new CocktailReviewLike {
Id = "1", CocktailReviewID = "1", AppUserID = "1"
};
//var like2 = new BarReviewLike { Id = "2", BarReviewID = "2", AppUserID="1" };
using (var arrangeContext = new CMContext(options))
{
var sut = new ReviewServices(arrangeContext);
arrangeContext.Add(cocktail);
arrangeContext.Add(user);
arrangeContext.Add(review1);
arrangeContext.Add(review2);
arrangeContext.Add(like1);
await arrangeContext.SaveChangesAsync();
var ex = await Assert.ThrowsExceptionAsync <MagicException>(
async() => await sut.LikeCocktailReview(review1.Id, user.Id)
);
}
}
public async Task Throw_MagicExeption_IfUserWithSuchId_DoesNotExist()
{
var options = TestUtils.GetOptions(nameof(Throw_MagicExeption_IfUserWithSuchId_DoesNotExist));
var userStoreMocked = new Mock <IUserStore <AppUser> >();
var userManagerMocked =
new Mock <UserManager <AppUser> >
(userStoreMocked.Object, null, null, null, null, null, null, null, null);
using (var arrangeContext = new CMContext(options))
{
//1
arrangeContext.Users.Add(new AppUser {
Id = "1", UserName = "******"
});
//2
arrangeContext.Users.Add(new AppUser {
Id = "2", UserName = "******"
});
//3
arrangeContext.Users.Add(new AppUser {
Id = "3", UserName = "******"
});
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new CMContext(options))
{
var sut = new AppUserServices(assertContext, userManagerMocked.Object);
var result = await Assert.ThrowsExceptionAsync <MagicException>
(async() => await sut.GetUsernameById("a3331s"));
}
}
public async Task ThrowCorrectMessage_WhenCocktailIsDeleted()
{
var options = TestUtils.GetOptions(nameof(ThrowCorrectMessage_WhenCocktailIsDeleted));
var cocktailId = "15";
var newCocktail = new Cocktail()
{
Id = cocktailId, DateDeleted = DateTime.Now
};
using (var arrangeContext = new CMContext(options))
{
arrangeContext.Add(newCocktail);
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new CMContext(options))
{
var sut = new CocktailServices(assertContext, _fileUploadService.Object,
_ingredientServices.Object, _recipeServices.Object);
var ex = await Assert.ThrowsExceptionAsync <MagicException>(
async() => await sut.FindCocktailById(cocktailId));
Assert.AreEqual("Cocktail doesn't exist in DB!", ex.Message);
}
}
public async Task RemoveLikeCocktailReview_WhenValidBarIdIsPassed()
{
var options = TestUtils.GetOptions(nameof(RemoveLikeCocktailReview_WhenValidBarIdIsPassed));
var cocktail = new Cocktail {
Id = "2"
};
var user = new AppUser {
Id = "1"
};
var review1 = new CocktailReview {
Id = "1", Rating = 6, Description = "0100101", CocktailId = "2"
};
var review2 = new CocktailReview {
Id = "2", Rating = 10, Description = "0100101", CocktailId = "2"
};
var like1 = new CocktailReviewLike {
Id = "1", AppUserID = "1", CocktailReviewID = review1.Id
};
//var like2 = new BarReviewLike { Id = "2", BarReviewID = "2", AppUserID="1" };
using (var arrangeContext = new CMContext(options))
{
var sut = new ReviewServices(arrangeContext);
arrangeContext.Add(cocktail);
arrangeContext.Add(user);
arrangeContext.Add(review1);
arrangeContext.Add(like1);
await arrangeContext.SaveChangesAsync();
Assert.AreEqual(1, arrangeContext.CocktailReviewLikes.Count());
await sut.RemoveCocktailReviewLike(review1.Id, user.Id);
Assert.AreEqual(0, arrangeContext.CocktailReviewLikes.Count());
}
}
public async Task EditComment_Updates_Correctly()
{
//Arrange
var options = Utils.GetOptions(nameof(EditComment_Updates_Correctly));
var user = new User {
Id = Guid.NewGuid(), UserName = "******"
};
var bar = new Bar {
Id = Guid.NewGuid(), Name = "Manhattan"
};
var barComment = new BarComment {
BarId = bar.Id, UserId = user.Id, Comments = "Good one"
};
using (var arrangeContext = new CMContext(options))
{
await arrangeContext.Bars.AddAsync(bar);
await arrangeContext.Users.AddAsync(user);
await arrangeContext.BarComments.AddAsync(barComment);
await arrangeContext.SaveChangesAsync();
}
//Act, Assert
using (var assertContext = new CMContext(options))
{
var sut = new BarCommentsServices(assertContext);
var result = await sut.EditComment(barComment.Id, "Changes made");
Assert.AreEqual("Changes made", result.Comments);
Assert.IsInstanceOfType(result, typeof(BarCommentDTO));
}
}
public async Task AddNotificationToDBForDeleteBar_WithCorrectParameters()
{
var options = TestUtils.GetOptions(nameof(AddNotificationToDBForDeleteBar_WithCorrectParameters));
var adminName = "pesho";
var id = "1";
var barName = "newBar";
var admin = new AppUser
{
Id = id,
UserName = adminName
};
_userServices.Setup(x => x.GetUsernameById(id))
.ReturnsAsync(admin.UserName);
_userServices.Setup(x => x.GetAdmin())
.ReturnsAsync(admin);
_iNotificationManager.Setup(x => x.BarDeletedDescription(adminName, barName))
.Returns($"LALAA");
using (var arrangeContext = new CMContext(options))
{
arrangeContext.Add(admin);
await arrangeContext.SaveChangesAsync();
Assert.AreEqual(0, arrangeContext.Notifications.Count());
var sut = new NotificationServices(arrangeContext, _userServices.Object,
_iNotificationManager.Object);
await sut.BarDeletedNotificationToAdminAsync(id, barName);
Assert.AreEqual(1, arrangeContext.Notifications.Count());
Assert.AreEqual("LALAA", arrangeContext.Notifications.First().Description);
Assert.AreEqual(adminName, arrangeContext.Notifications.First().Username);
}
}
public async Task CreateCocktail_Returns_Correct()
{
//Arrange
var options = Utils.GetOptions(nameof(CreateCocktail_Returns_Correct));
var cocktail = new CocktailDTO
{
Name = "Cuba Libre",
IsAlcoholic = true,
};
//Act, Assert
using (var assertContext = new CMContext(options))
{
var sut = new CocktailServices(assertContext);
var result = await sut.CreateCocktail(cocktail);
Assert.AreEqual(cocktail.Name, result.Name);
Assert.AreEqual(true, result.IsAlcoholic);
Assert.IsInstanceOfType(result, typeof(CocktailDTO));
}
}
public async Task EditComment_Throws_When_ContentIsNull()
{
//Arrange
var options = Utils.GetOptions(nameof(EditComment_Throws_When_ContentIsNull));
var user = new User {
Id = Guid.NewGuid(), UserName = "******"
};
var bar = new Bar {
Id = Guid.NewGuid(), Name = "Manhattan"
};
var barComment = new BarComment {
BarId = bar.Id, UserId = user.Id, Comments = "I like it"
};
var commentId = Guid.NewGuid();
string commentToChange = "";
using (var arrangeContext = new CMContext(options))
{
await arrangeContext.Bars.AddAsync(bar);
await arrangeContext.Users.AddAsync(user);
await arrangeContext.BarComments.AddAsync(barComment);
await arrangeContext.SaveChangesAsync();
}
//Act, Assert
using (var assertContext = new CMContext(options))
{
var sut = new BarCommentsServices(assertContext);
await Assert.ThrowsExceptionAsync <ArgumentNullException>(() => sut.EditComment(commentId, commentToChange));
}
}