public async Task <UserDTO> UpdateAsync(Guid id, UserDTO userDTO, UserManager <User> userManager)
{
try
{
var user = await _context.Users
.Include(u => u.BarRatings)
.Include(u => u.CocktailRatings)
.Include(u => u.BarComments)
.Include(u => u.CocktailComments)
.FirstOrDefaultAsync(u => u.Id == id);
await userManager.SetLockoutEnabledAsync(user, true);
await userManager.SetLockoutEndDateAsync(user, userDTO.LockoutEnd);
var status = userManager.GetLockoutEndDateAsync(user);
await _context.SaveChangesAsync();
return(userDTO);
}
catch (Exception)
{
throw new ArgumentNullException("Failed to update");
}
}
/// <summary>
/// User rates a cocktail
/// </summary>
/// <param name="userId">User Id, Guid</param>
/// <param name="cocktailId">Cocktail Id, Guid</param>
/// <param name="theRating">Rating, 1 to 5 </param>
/// <returns>The cocktail rated, DTO</returns>
public async Task <CocktailDTO> RateCocktail(int theRating, Guid cocktailId, Guid userId)
{
var user = await _context.Users
.FirstOrDefaultAsync(u => u.Id == userId);
var cocktail = await _context.Cocktails
.FirstOrDefaultAsync(c => c.Id == cocktailId);
var existingRating = await _context.CocktailRatings
.FirstOrDefaultAsync(r => r.UserId == userId && r.CocktailId == cocktailId);
//bool isRated = this._context.CocktailRatings
// .Select(r => r.UserId == userId && r.CocktailId == cocktailId)
// .Count() == 1;
if (existingRating != null)
{
existingRating.Rating = theRating;
_context.CocktailRatings.Update(existingRating);
}
else
{
var theNewRating = new UserCocktailRating
{
CocktailId = cocktailId,
Cocktail = cocktail,
UserId = userId,
User = user,
Rating = theRating,
};
cocktail.TimesRated += 1;
_context.CocktailRatings.Add(theNewRating);
}
try
{
//Saving before recalculating for it to be correct.
await _context.SaveChangesAsync();
}
catch (Exception)
{
return(null);
}
cocktail.Rating = await RecalculateCocktailRatingAsync(cocktail.Id);
try
{
_context.Cocktails.Update(cocktail);
await _context.SaveChangesAsync();
}
catch (Exception)
{
return(null);
}
return(_cocktailMapper.MapEntityToDTO(cocktail));
}
/// <summary>
/// Creates new ingredient in the database.
/// </summary>
/// <param name="ingredientDTO">Ingredient DTO model.</param>
/// <returns>The created ingredient.</returns>
public async Task <IngredientDTO> CreateAsync(IngredientDTO ingredientDTO)
{
var ingredient = _mapper.MapDTOToEntity(ingredientDTO);
// Initialize with empty list, here not in the mapper
ingredient.Cocktails = new List <CocktailIngredient>();
_context.Ingredients.Add(ingredient);
await _context.SaveChangesAsync();
ingredient = await _context.Ingredients.FirstOrDefaultAsync(x => x.Name.ToLower() == ingredientDTO.Name.ToLower());
return(_mapper.MapEntityToDTO(ingredient));
}
public async Task CocktailExists_True_whenExisting()
{
var options = Utils.GetOptions(nameof(CocktailExists_True_whenExisting));
var testCocktailId = Utils.MySampleGuid();
var cocktail = new Cocktail()
{
Id = testCocktailId
};
var mockMapper = new Mock <ICocktailMapper>();
var mockBarMapper = new Mock <IBarMapper>();
using (var arrangeContext = new BCcontext(options))
{
await arrangeContext.Cocktails.AddAsync(cocktail);
await arrangeContext.SaveChangesAsync();
}
//Act and Assert
using (var context = new BCcontext(options))
{
var sut = new CocktailsService(context, mockMapper.Object, mockBarMapper.Object);
var result = sut.CocktailExists(testCocktailId);
Assert.IsTrue(result);
}
}
public async Task CocktailExistsByName_True_whenExisting()
{
var options = Utils.GetOptions(nameof(CocktailExistsByName_True_whenExisting));
var mockMapper = new Mock <ICocktailMapper>();
var mockBarMapper = new Mock <IBarMapper>();
var testCocktailName = "TestCocktailName";
var cocktail = new Cocktail()
{
Name = testCocktailName
};
using (var arrangeContext = new BCcontext(options))
{
await arrangeContext.Cocktails.AddAsync(cocktail);
await arrangeContext.SaveChangesAsync();
}
//Act and Assert
using (var context = new BCcontext(options))
{
var sut = new CocktailsService(context, mockMapper.Object, mockBarMapper.Object);
var result = await sut.CocktailExistsByNameAsync("TestCocktailName");
Assert.IsTrue(result);
}
}
private static async Task SeedBars(BCcontext context)
{
if (!(await context.Bars.AnyAsync()))
{
var barList = new List <Bar>();
for (int i = 1; i < 20; i++)
{
var bar = new Bar()
{
Name = "BestBar" + i,
Rating = 4,
TimesRated = 1,
ImageSrc = null,
IsDeleted = false,
Address = "Street " + i,
Country = "България",
District = "District " + i,
Email = "*****@*****.**",
Phone = "+ " + i + "8888888",
Town = "София",
LocationId = null,
};
barList.Add(bar);
}
await context.Bars.AddRangeAsync(barList);
await context.SaveChangesAsync();
}
}
public async Task RecoverCocktail_When_ItIsDeleted()
{
var testCocktailName = "TestCocktailName";
var options = Utils.GetOptions(nameof(RecoverCocktail_When_ItIsDeleted));
var entityCocktail = new Cocktail()
{
Name = testCocktailName,
IsDeleted = true,
};
var dto = new CocktailDTO()
{
Name = testCocktailName,
};
var mockMapper = new Mock <ICocktailMapper>();
mockMapper.Setup(x => x.MapDTOToEntity(It.IsAny <CocktailDTO>()))
.Returns((CocktailDTO x) => new Cocktail()
{
Name = x.Name,
});
mockMapper.Setup(x => x.MapEntityToDTO(It.IsAny <Cocktail>()))
.Returns((Cocktail x) => new CocktailDTO()
{
Name = x.Name,
});
var mockBarMapper = new Mock <IBarMapper>();
using (var arrangeContext = new BCcontext(options))
{
await arrangeContext.Cocktails
.AddAsync(entityCocktail);
await arrangeContext.SaveChangesAsync();
}
using (var actContext = new BCcontext(options))
{
var sut = new CocktailsService(actContext, mockMapper.Object, mockBarMapper.Object);
var cocktail = sut.CreateAsync(dto);
await actContext.SaveChangesAsync();
}
using (var assertContext = new BCcontext(options))
{
var sut = new CocktailsService(assertContext, mockMapper.Object, mockBarMapper.Object);
var cocktail = await sut.CreateAsync(dto);
Assert.AreEqual(1, assertContext.Cocktails.Count());
Assert.IsNotNull(cocktail);
Assert.AreEqual(testCocktailName, testCocktailName);
Assert.IsFalse(cocktail.IsDeleted);
}
}
public async Task ThrowArgumentException_IfExceptionOccurs()
{
//Arrange
var options = Utils.GetOptions(nameof(ThrowArgumentException_IfExceptionOccurs));
var record = new Bar()
{
Name = "BestBar",
Rating = 0,
TimesRated = 0,
ImageSrc = null,
IsDeleted = false,
Address = "Галичица 17.",
Country = "България.",
District = "Лозенец.",
Email = "*****@*****.**",
Phone = "088888888.",
Town = "София.",
LocationId = null,
};
var user = new User()
{
UserName = "******",
Email = "*****@*****.**",
PasswordHash = "pass",
};
using (var context = new BCcontext(options))
{
await context.Bars.AddAsync(record);
await context.Users.AddAsync(user);
await context.SaveChangesAsync();
}
var mockMapper = new Mock <IBarMapper>();
mockMapper.Setup((x) => x.MapEntityToDTO(It.IsAny <Bar>()))
.Returns(() => throw new Exception());
var http = new Mock <IHttpClientFactory>();
var coctailMapper = new Mock <ICocktailMapper>();
//Act & Assert
using (var context = new BCcontext(options))
{
var sut = new BarsService(context, mockMapper.Object, http.Object, coctailMapper.Object);
var dbResult = await context.Bars.FirstOrDefaultAsync(b => b.Name == "BestBar");
var dbUser = await context.Users.FirstOrDefaultAsync(u => u.UserName == "UserName");
await Assert.ThrowsExceptionAsync <ArgumentException>(async() => await sut.RateBarAsync(dbResult.Id, dbUser.Id, 4));
}
}
public async Task CreateIngredient_When_IngredientDoesNotExist()
{
var options = Utils.GetOptions(nameof(CreateIngredient_When_IngredientDoesNotExist));
var testIngredientName = "IngredientName";
var entity = new Ingredient()
{
Name = "SampleIngredientName",
IsAlcoholic = true,
};
var mockMapper = new Mock <IIngredientMapper>();
mockMapper.Setup(x => x.MapDTOToEntity(It.IsAny <IngredientDTO>()))
.Returns((IngredientDTO i) => new Ingredient()
{
Name = testIngredientName,
IsAlcoholic = true
});
mockMapper.Setup(x => x.MapEntityToDTO(It.IsAny <Ingredient>()))
.Returns((Ingredient i) => new IngredientDTO()
{
Name = testIngredientName,
IsAlcoholic = true
});
using (var arrangeContext = new BCcontext(options))
{
await arrangeContext.Ingredients
.AddAsync(entity);
await arrangeContext.SaveChangesAsync();
}
using (var actContext = new BCcontext(options))
{
var sut = new IngredientsService(actContext, mockMapper.Object);
var ingredient = new IngredientDTO()
{
Name = testIngredientName,
IsAlcoholic = true,
};
var testIngredient = await sut.CreateAsync(ingredient);
await actContext.SaveChangesAsync();
}
using (var assertContext = new BCcontext(options))
{
Assert.AreEqual(2, assertContext.Ingredients.Count());
var ingredient = await assertContext.Ingredients.FirstOrDefaultAsync(x => x.Name == testIngredientName);
Assert.IsNotNull(ingredient);
Assert.IsTrue(ingredient.IsAlcoholic);
}
}
public async Task ReturnCorrect_whenValidCocktail()
{
var testCocktailName = "TestCocktailName";
var options = Utils.GetOptions(nameof(ReturnCorrect_whenValidCocktail));
var cocktailId = Utils.MySampleGuid3();
var entityCocktail = new Cocktail()
{
Id = Utils.MySampleGuid(),
Name = testCocktailName
};
var sampleCocktail = new Cocktail()
{
Id = Utils.MySampleGuid2(),
Name = "SampleCocktailName",
};
var mockMapper = new Mock <ICocktailMapper>();
mockMapper.Setup(x => x.MapDTOToEntity(It.IsAny <CocktailDTO>()))
.Returns((CocktailDTO x) => new Cocktail()
{
Name = x.Name,
});
mockMapper.Setup(x => x.MapEntityToDTO(It.IsAny <Cocktail>()))
.Returns((Cocktail x) => new CocktailDTO()
{
Id = x.Id,
Name = x.Name,
});
var mockBarMapper = new Mock <IBarMapper>();
using (var arrangeContext = new BCcontext(options))
{
await arrangeContext.Cocktails
.AddRangeAsync(entityCocktail, sampleCocktail);
await arrangeContext.SaveChangesAsync();
}
using (var actContext = new BCcontext(options))
{
var sut = new CocktailsService(actContext, mockMapper.Object, mockBarMapper.Object);
var cocktail = await sut.GetAsync(Utils.MySampleGuid());
Assert.AreEqual(2, actContext.Cocktails.Count());
Assert.IsNotNull(cocktail);
Assert.AreEqual(entityCocktail.Id, cocktail.Id);
Assert.AreEqual(testCocktailName, cocktail.Name);
}
}
public async Task ThrowsArgumentExceptionWhenFailedToGetBestBars()
{
var options = Utils.GetOptions(nameof(ThrowsArgumentExceptionWhenFailedToGetBestBars));
var barList = new List <Bar>();
for (int i = 1; i <= 3; i++)
{
var bar = new Bar()
{
Name = "BestBar" + i,
Rating = 3,
TimesRated = i,
ImageSrc = null,
IsDeleted = false,
Address = "Street " + i,
Country = "България",
District = "District " + i,
Email = "*****@*****.**",
Phone = "+ " + i + "8888888",
Town = "София",
LocationId = null,
};
barList.Add(bar);
}
using (var context = new BCcontext(options))
{
await context.Bars.AddRangeAsync(barList);
await context.SaveChangesAsync();
}
var mockMapper = new Mock <IBarMapper>();
mockMapper.Setup((x) => x.MapEntityToDTO(It.IsAny <Bar>()))
.Returns(() => throw new Exception());
var http = new Mock <IHttpClientFactory>();
var coctailMapper = new Mock <ICocktailMapper>();
//Act & Assert
using (var context = new BCcontext(options))
{
var sut = new BarsService(context, mockMapper.Object, http.Object, coctailMapper.Object);
await Assert.ThrowsExceptionAsync <ArgumentException>(async() => await sut.GetBestBarsAsync(), "Failed to get list");
}
}
public async Task <BarUserCommentDTO> CreateAsync(BarUserCommentDTO commentDTO)
{
try
{
if (await CombinationExistAsync(commentDTO.BarId, commentDTO.UserId))
{
return(new BarUserCommentDTO());
}
else
{
var comment = this._mapper.MapDTOToEntity(commentDTO);
this._context.BarComments.Add(comment);
await _context.SaveChangesAsync();
return(commentDTO);
}
}
catch (Exception)
{
return(new BarUserCommentDTO());
}
}
public async Task <CocktailUserCommentDTO> CreateAsync(CocktailUserCommentDTO commentDTO)
{
try
{
if (await CombinationExistAsync(commentDTO.CocktailId, commentDTO.UserId))
{
return(new CocktailUserCommentDTO());
}
else
{
var comment = _mapper.MapDTOToEntity(commentDTO);
_context.CocktailComments.Add(comment);
await _context.SaveChangesAsync();
return(commentDTO);
}
}
catch (Exception)
{
return(new CocktailUserCommentDTO());
}
}
public async Task ReturnSetNumberOfUsers()
{
//Arrange
var options = Utils.GetOptions(nameof(ReturnSetNumberOfUsers));
var userList = new List <User>();
for (int i = 1; i <= 20; i++)
{
var user = new User()
{
UserName = "******" + i,
Email = "*****@*****.**" + i,
PasswordHash = "pass",
};
userList.Add(user);
}
using (var context = new BCcontext(options))
{
await context.Users.AddRangeAsync(userList);
await context.SaveChangesAsync();
}
var mockMapper = new Mock <IUserMapper>();
mockMapper.Setup((x) => x.MapEntityToDTO(It.IsAny <User>()))
.Returns((User u) => new UserDTO()
{
Id = u.Id,
UserName = u.UserName,
Email = u.Email,
});
var coctailMapper = new Mock <ICocktailCommentMapper>();
//Act & Assert
using (var context = new BCcontext(options))
{
var sut = new UsersService(context, mockMapper.Object, coctailMapper.Object);
var result = await sut.GetAllAsync("0", "5", "1");
Assert.AreEqual(result.Count(), 5);
}
}
public async Task ReturnTrue_WhenBarDeleted()
{
//Arrange
var options = Utils.GetOptions(nameof(ReturnTrue_WhenBarDeleted));
var record = new Bar()
{
Name = "BestBar",
Rating = 4,
TimesRated = 1,
ImageSrc = null,
IsDeleted = false,
Address = "Галичица 17.",
Country = "България.",
District = "Лозенец.",
Email = "*****@*****.**",
Phone = "088888888.",
Town = "София.",
LocationId = null,
};
using (var context = new BCcontext(options))
{
await context.Bars.AddAsync(record);
await context.SaveChangesAsync();
}
var mockMapper = new Mock <IBarMapper>();
var http = new Mock <IHttpClientFactory>();
var coctailMapper = new Mock <ICocktailMapper>();
//Act & Assert
using (var context = new BCcontext(options))
{
var sut = new BarsService(context, mockMapper.Object, http.Object, coctailMapper.Object);
var dbResult = await context.Bars.FirstOrDefaultAsync(b => b.Name == "BestBar");
var result = await sut.DeleteAsync(dbResult.Id);
dbResult = await context.Bars.FirstOrDefaultAsync(b => b.Name == "BestBar");
Assert.AreEqual(result, true);
Assert.AreEqual(dbResult.IsDeleted, true);
}
}
public async Task GetCorrectUser_WhenSuccessful()
{
//Arrange
var options = Utils.GetOptions(nameof(GetCorrectUser_WhenSuccessful));
var user = new User()
{
UserName = "******",
Email = "*****@*****.**",
PasswordHash = "pass",
};
using (var context = new BCcontext(options))
{
await context.Users.AddAsync(user);
await context.SaveChangesAsync();
}
var mockMapper = new Mock <IUserMapper>();
mockMapper.Setup((x) => x.MapEntityToDTO(It.IsAny <User>()))
.Returns((User u) => new UserDTO()
{
Id = u.Id,
UserName = u.UserName,
Email = u.Email,
});
var coctailMapper = new Mock <ICocktailCommentMapper>();
//Act & Assert
using (var context = new BCcontext(options))
{
var sut = new UsersService(context, mockMapper.Object, coctailMapper.Object);
var dbResult = await context.Users.FirstOrDefaultAsync(b => b.UserName == "UserName1");
var result = await sut.GetAsync(dbResult.Id);
Assert.AreEqual(dbResult.UserName, result.UserName);
Assert.AreEqual(dbResult.Email, result.Email);
}
}
public async Task AddIngredientsToCocktail_False_whenNotValid()
{
var options = Utils.GetOptions(nameof(AddIngredientsToCocktail_False_whenNotValid));
var cocktail = new Cocktail()
{
Id = Utils.MySampleGuid(),
};
var ingredient = new Ingredient()
{
Id = Utils.MySampleGuid2()
};
var entity = new CocktailIngredient()
{
IngredientId = ingredient.Id,
Ingredient = ingredient,
CocktailId = cocktail.Id,
Cocktail = cocktail,
Parts = 2
};
var mockMapper = new Mock <ICocktailMapper>();
var mockBarMapper = new Mock <IBarMapper>();
using (var arrangeContext = new BCcontext(options))
{
await arrangeContext.Ingredients.AddAsync(ingredient);
await arrangeContext.CocktailIngredients.AddAsync(entity);
await arrangeContext.SaveChangesAsync();
}
using (var context = new BCcontext(options))
{
var sut = new CocktailsService(context, mockMapper.Object, mockBarMapper.Object);
var result = await sut.AddIngredientsToCocktail(cocktail, ingredient.Id, 2);
Assert.IsFalse(result);
}
}
/// <summary>
/// Creates new bar in the database.
/// </summary>
/// <param name="barDTO">bar DTO model.</param>
/// <returns>The created bar.</returns>
public async Task <BarDTO> CreateAsync(BarDTO barDTO)
{
try
{
if (await BarExistsByName(barDTO.Name))
{
var theBar = await _context.Bars
.FirstOrDefaultAsync(c => c.Name.Equals(barDTO.Name));
if (theBar.IsDeleted == true)
{
theBar.IsDeleted = false;
}
_context.Bars.Update(theBar);
await _context.SaveChangesAsync();
return(_mapper.MapEntityToDTO(theBar));
}
else
{
var bar = _mapper.MapDTOToEntity(barDTO);
_context.Bars.Add(bar);
await _context.SaveChangesAsync();
bar = await _context.Bars.FirstOrDefaultAsync(b => b.Name == barDTO.Name);
return(_mapper.MapEntityToDTO(bar));
}
}
catch (Exception)
{
throw new ArgumentNullException("Fail to create bar");
}
}
public async Task ThrowArgumentException_WhenExceptionHappens()
{
//Arrange
var options = Utils.GetOptions(nameof(ReturnUserDTO_WhenGetSuccesfull));
var user = new User()
{
UserName = "******",
Email = "*****@*****.**",
PasswordHash = "pass",
};
using (var context = new BCcontext(options))
{
await context.Users.AddAsync(user);
await context.SaveChangesAsync();
}
var mockMapper = new Mock <IUserMapper>();
mockMapper.Setup((x) => x.MapEntityToDTO(It.IsAny <User>()))
.Returns(() => throw new Exception());
var coctailMapper = new Mock <ICocktailCommentMapper>();
//Act & Assert
using (var context = new BCcontext(options))
{
var sut = new UsersService(context, mockMapper.Object, coctailMapper.Object);
var dbResult = await context.Users.FirstOrDefaultAsync(b => b.UserName == "UserName1");
await Assert.ThrowsExceptionAsync <ArgumentException>(async() => await sut.GetAsync(dbResult.Id));
}
}
public async Task CreateComment_whenAlreadyCommented()
{
var testBarName = "TestBarName";
var testUserName = "******";
var options = Utils.GetOptions(nameof(CreateComment_whenAlreadyCommented));
var testUser = new User()
{
Id = Utils.MySampleGuid(),
UserName = testUserName,
};
var testBar = new Bar()
{
Id = Utils.MySampleGuid3(),
Name = testBarName,
};
var testComment = new BarUserComment()
{
UserId = testUser.Id,
User = testUser,
BarId = testBar.Id,
Bar = testBar,
Text = "Comment text here.",
};
var dto = new BarUserCommentDTO()
{
UserId = testUser.Id,
BarId = testBar.Id,
Text = "New comment text here.",
};
var mockMapper = new Mock <IBarUserCommentMapper>();
mockMapper.Setup(x => x.MapDTOToEntity(It.IsAny <BarUserCommentDTO>()))
.Returns((BarUserCommentDTO x) => new BarUserComment()
{
BarId = x.BarId,
UserId = x.UserId,
Text = x.Text
});
mockMapper.Setup(x => x.MapEntityToDTO(It.IsAny <BarUserComment>()))
.Returns((BarUserComment x) => new BarUserCommentDTO()
{
BarId = x.BarId,
BarName = x.Bar.Name,
UserId = x.UserId,
UserName = x.User.UserName,
Text = x.Text
});
using (var arrangeContext = new BCcontext(options))
{
await arrangeContext.Users.AddAsync(testUser);
await arrangeContext.Bars.AddAsync(testBar);
await arrangeContext.BarComments.AddAsync(testComment);
await arrangeContext.SaveChangesAsync();
}
using (var context = new BCcontext(options))
{
var sut = new BarUserCommentsService(context, mockMapper.Object);
//Act
var result = await sut.CreateAsync(dto);
//Assert
Assert.AreNotEqual(testBar.Id, result.BarId);
Assert.IsNull(result.BarName);
Assert.AreNotEqual(testUser.Id, result.UserId);
Assert.IsNull(result.UserName);
Assert.IsNull(result.Text);
Assert.AreEqual(1, context.BarComments.Count());
var bar = await context.Bars
.Include(x => x.Comments)
.FirstOrDefaultAsync(x => x.Name == testBarName);
var comment = bar.Comments.FirstOrDefault();
Assert.IsNotNull(comment);
Assert.AreNotEqual(dto.Text, comment.Text);
}
}
public async Task CreateCocktailComment_whenValid()
{
var testCocktailName = "TestCocktailName";
var testUserName = "******";
var options = Utils.GetOptions(nameof(CreateCocktailComment_whenValid));
var testUser = new User()
{
Id = Utils.MySampleGuid(),
UserName = testUserName,
};
var testCocktail = new Cocktail()
{
Id = Utils.MySampleGuid3(),
Name = testCocktailName,
};
var dto = new CocktailUserCommentDTO()
{
UserId = testUser.Id,
CocktailId = testCocktail.Id,
Text = "Comment text here.",
};
var mockMapper = new Mock <ICocktailCommentMapper>();
mockMapper.Setup(x => x.MapDTOToEntity(It.IsAny <CocktailUserCommentDTO>()))
.Returns((CocktailUserCommentDTO x) => new CocktailUserComment()
{
CocktailId = x.CocktailId,
UserId = x.UserId,
Text = x.Text
});
mockMapper.Setup(x => x.MapEntityToDTO(It.IsAny <CocktailUserComment>()))
.Returns((CocktailUserComment x) => new CocktailUserCommentDTO()
{
CocktailId = x.CocktailId,
CocktailName = x.Cocktail.Name,
UserId = x.UserId,
UserName = x.User.UserName,
Text = x.Text
});
using (var arrangeContext = new BCcontext(options))
{
await arrangeContext.Users.AddAsync(testUser);
await arrangeContext.Cocktails
.AddAsync(testCocktail);
await arrangeContext.SaveChangesAsync();
}
using (var actContext = new BCcontext(options))
{
var sut = new CocktailCommentsService(actContext, mockMapper.Object);
var comment = sut.CreateAsync(dto);
await actContext.SaveChangesAsync();
}
using (var assertContext = new BCcontext(options))
{
Assert.AreEqual(1, assertContext.CocktailComments.Count());
var cocktail = await assertContext.Cocktails
.Include(x => x.Comments)
.FirstOrDefaultAsync(x => x.Name == testCocktailName);
var comment = cocktail.Comments.FirstOrDefault();
Assert.IsNotNull(comment);
Assert.AreEqual(dto.Text, comment.Text);
}
}
public async Task CreateCocktail_When_ItDoesNotExist()
{
var testCocktailName = "TestCocktailName";
var options = Utils.GetOptions(nameof(CreateCocktail_When_ItDoesNotExist));
var ingredient1 = new Ingredient()
{
Id = Utils.MySampleGuid(),
Name = "SampleIngredientName",
IsAlcoholic = true,
};
var ingredient2 = new Ingredient()
{
Id = Utils.MySampleGuid2(),
Name = "SampleIngredientName",
IsAlcoholic = true,
};
var entityCocktail = new Cocktail()
{
Name = "SampleCocktailName"
};
var mockMapper = new Mock <ICocktailMapper>();
mockMapper.Setup(x => x.MapDTOToEntity(It.IsAny <CocktailDTO>()))
.Returns((CocktailDTO x) => new Cocktail()
{
Name = x.Name,
});
mockMapper.Setup(x => x.MapEntityToDTO(It.IsAny <Cocktail>()))
.Returns((Cocktail x) => new CocktailDTO()
{
Name = x.Name,
});
var mockBarMapper = new Mock <IBarMapper>();
var dto = new CocktailDTO()
{
Name = testCocktailName,
IsAlcoholic = true,
Ingredients = new List <CocktailIngredientDTO>()
{
new CocktailIngredientDTO()
{
IngredientId = Utils.MySampleGuid3(),
Parts = 2
}
},
};
var ingredient = new Ingredient()
{
Id = Utils.MySampleGuid3(),
IsAlcoholic = true,
};
var sampleEntity = new Cocktail()
{
Name = "TestName", IsAlcoholic = false, IsDeleted = true
};
using (var arrangeContext = new BCcontext(options))
{
await arrangeContext.Ingredients.AddAsync(ingredient);
await arrangeContext.Cocktails
.AddAsync(entityCocktail);
await arrangeContext.SaveChangesAsync();
}
using (var actContext = new BCcontext(options))
{
var sut = new CocktailsService(actContext, mockMapper.Object, mockBarMapper.Object);
var cocktail = sut.CreateAsync(dto);
await actContext.SaveChangesAsync();
}
using (var assertContext = new BCcontext(options))
{
Assert.AreEqual(2, assertContext.Cocktails.Count());
var cocktail = await assertContext.Cocktails
.FirstOrDefaultAsync(x => x.Name == testCocktailName);
Assert.IsNotNull(cocktail);
Assert.AreEqual(testCocktailName, cocktail.Name);
Assert.IsTrue(cocktail.IsAlcoholic);
}
}
public async Task ChangeRating_IfAlreadyRatedButNotTimesRated()
{
//Arrange
var options = Utils.GetOptions(nameof(ChangeRating_IfAlreadyRatedButNotTimesRated));
var record = new Bar()
{
Name = "BestBar",
Rating = 4,
TimesRated = 1,
ImageSrc = null,
IsDeleted = false,
Address = "Галичица 17.",
Country = "България.",
District = "Лозенец.",
Email = "*****@*****.**",
Phone = "088888888.",
Town = "София.",
LocationId = null,
};
var user = new User()
{
UserName = "******",
Email = "*****@*****.**",
PasswordHash = "pass",
};
using (var context = new BCcontext(options))
{
await context.Bars.AddAsync(record);
await context.Users.AddAsync(user);
await context.SaveChangesAsync();
var barRating = new UserBarRating();
barRating.Bar = await context.Bars.FirstOrDefaultAsync(b => b.Name == "BestBar");
barRating.User = await context.Users.FirstOrDefaultAsync(u => u.UserName == "UserName");
barRating.Rating = 4;
await context.BarRatings.AddAsync(barRating);
await context.SaveChangesAsync();
}
var mockMapper = new Mock <IBarMapper>();
mockMapper.Setup((x) => x.MapEntityToDTO(It.IsAny <Bar>()))
.Returns((Bar b) => new BarDTO()
{
Id = b.Id,
Name = b.Name,
Rating = b.Rating,
TimesRated = b.TimesRated,
ImageSrc = b.ImageSrc,
IsDeleted = b.IsDeleted,
Address = b.Address,
Country = b.Country,
District = b.District,
Email = b.Email,
LocationId = b.LocationId,
Phone = b.Phone,
Town = b.Town
});
var http = new Mock <IHttpClientFactory>();
var coctailMapper = new Mock <ICocktailMapper>();
//Act & Assert
using (var context = new BCcontext(options))
{
var sut = new BarsService(context, mockMapper.Object, http.Object, coctailMapper.Object);
var dbResult = await context.Bars.FirstOrDefaultAsync(b => b.Name == "BestBar");
var dbUser = await context.Users.FirstOrDefaultAsync(u => u.UserName == "UserName");
var result = await sut.RateBarAsync(dbResult.Id, dbUser.Id, 2);
dbResult = await context.Bars.FirstOrDefaultAsync(b => b.Name == "BestBar");
Assert.AreEqual(dbResult.TimesRated, 1);
Assert.AreEqual(dbResult.Rating, 2);
}
}
public async Task ThrowArgumentException_WhenParametersIncorrect()
{
//Arrange
var options = Utils.GetOptions(nameof(ThrowArgumentException_WhenParametersIncorrect));
var record = new Bar()
{
Name = "BestBar",
Rating = 4,
TimesRated = 1,
ImageSrc = null,
IsDeleted = false,
Address = "Галичица 17.",
Country = "България.",
District = "Лозенец.",
Email = "*****@*****.**",
Phone = "088888888.",
Town = "София.",
LocationId = null,
};
var cocktailList = new List <Cocktail>();
for (int i = 1; i <= 20; i++)
{
var cocktail = new Cocktail()
{
Name = "BestCocktail" + i,
Rating = 4,
TimesRated = 1,
ImageSrc = null,
IsDeleted = false,
IsAlcoholic = false
};
cocktailList.Add(cocktail);
}
using (var context = new BCcontext(options))
{
await context.Bars.AddAsync(record);
await context.Cocktails.AddRangeAsync(cocktailList);
await context.SaveChangesAsync();
var bar = await context.Bars.FirstOrDefaultAsync();
var cocktails = await context.Cocktails.ToListAsync();
foreach (var item in cocktails)
{
var join = new CocktailBar()
{
Bar = bar,
Cocktail = item,
};
await context.CocktailBars.AddAsync(join);
}
await context.SaveChangesAsync();
}
var mockMapper = new Mock <IBarMapper>();
var http = new Mock <IHttpClientFactory>();
var coctailMapper = new Mock <ICocktailMapper>();
coctailMapper.Setup((x) => x.MapEntityToDTO(It.IsAny <Cocktail>()))
.Returns((Cocktail b) => new CocktailDTO()
{
Id = b.Id,
Name = b.Name,
Rating = b.Rating,
TimesRated = b.TimesRated,
ImageSrc = b.ImageSrc,
IsDeleted = b.IsDeleted,
IsAlcoholic = b.IsAlcoholic
});
//Act & Assert
using (var context = new BCcontext(options))
{
var sut = new BarsService(context, mockMapper.Object, http.Object, coctailMapper.Object);
var dbBar = await context.Bars.FirstOrDefaultAsync();
await Assert.ThrowsExceptionAsync <ArgumentException>(async() => await sut.GetCocktailsAsync(dbBar.Id, string.Empty, "8", null, true));
}
}
public async Task GetDefinedBarCocktails_WhenSuccessful()
{
//Arrange
var options = Utils.GetOptions(nameof(GetDefinedBarCocktails_WhenSuccessful));
var record = new Bar()
{
Name = "BestBar",
Rating = 4,
TimesRated = 1,
ImageSrc = null,
IsDeleted = false,
Address = "Галичица 17.",
Country = "България.",
District = "Лозенец.",
Email = "*****@*****.**",
Phone = "088888888.",
Town = "София.",
LocationId = null,
};
var cocktailList = new List <Cocktail>();
for (int i = 1; i <= 20; i++)
{
var cocktail = new Cocktail()
{
Name = "BestCocktail" + i,
Rating = 4,
TimesRated = 1,
ImageSrc = null,
IsDeleted = false,
IsAlcoholic = false
};
cocktailList.Add(cocktail);
}
using (var context = new BCcontext(options))
{
await context.Bars.AddAsync(record);
await context.Cocktails.AddRangeAsync(cocktailList);
await context.SaveChangesAsync();
var bar = await context.Bars.FirstOrDefaultAsync();
var cocktails = await context.Cocktails.ToListAsync();
foreach (var item in cocktails)
{
var join = new CocktailBar()
{
Bar = bar,
Cocktail = item,
};
await context.CocktailBars.AddAsync(join);
}
await context.SaveChangesAsync();
}
var mockMapper = new Mock <IBarMapper>();
var http = new Mock <IHttpClientFactory>();
var coctailMapper = new Mock <ICocktailMapper>();
coctailMapper.Setup((x) => x.MapEntityToDTO(It.IsAny <Cocktail>()))
.Returns((Cocktail b) => new CocktailDTO()
{
Id = b.Id,
Name = b.Name,
Rating = b.Rating,
TimesRated = b.TimesRated,
ImageSrc = b.ImageSrc,
IsDeleted = b.IsDeleted,
IsAlcoholic = b.IsAlcoholic
});
//Act & Assert
using (var context = new BCcontext(options))
{
var sut = new BarsService(context, mockMapper.Object, http.Object, coctailMapper.Object);
var dbResult = await context.CocktailBars
.Include(c => c.Cocktail)
.Skip(8).Take(8)
.ToListAsync();
var dbBar = await context.Bars.FirstOrDefaultAsync();
var result = await sut.GetCocktailsAsync(dbBar.Id, "1", "8", null, true);
Assert.AreEqual(result.Count(), dbResult.Count());
foreach (var item in dbResult)
{
Assert.IsNotNull(result.FirstOrDefault(r => r.Name == item.Cocktail.Name));
}
}
}
public async Task ReturnUndeletedRecords_IfNotAdmin()
{
//Arrange
var options = Utils.GetOptions(nameof(ReturnUndeletedRecords_IfNotAdmin));
var barList = new List <Bar>();
for (int i = 1; i <= 20; i++)
{
var bar = new Bar()
{
Name = "BestBar" + i,
Rating = 4,
TimesRated = 1,
ImageSrc = null,
IsDeleted = false,
Address = "Street " + i,
Country = "България",
District = "District " + i,
Email = "*****@*****.**",
Phone = "+ " + i + "8888888",
Town = "София",
LocationId = null,
};
if (i % 2 == 0)
{
bar.IsDeleted = true;
}
barList.Add(bar);
}
using (var context = new BCcontext(options))
{
await context.Bars.AddRangeAsync(barList);
await context.SaveChangesAsync();
}
var mockMapper = new Mock <IBarMapper>();
mockMapper.Setup((x) => x.MapEntityToDTO(It.IsAny <Bar>()))
.Returns((Bar b) => new BarDTO()
{
Id = b.Id,
Name = b.Name,
Rating = b.Rating,
TimesRated = b.TimesRated,
ImageSrc = b.ImageSrc,
IsDeleted = b.IsDeleted,
Address = b.Address,
Country = b.Country,
District = b.District,
Email = b.Email,
LocationId = b.LocationId,
Phone = b.Phone,
Town = b.Town
});
var http = new Mock <IHttpClientFactory>();
var coctailMapper = new Mock <ICocktailMapper>();
//Act & Assert
using (var context = new BCcontext(options))
{
var sut = new BarsService(context, mockMapper.Object, http.Object, coctailMapper.Object);
var result = await sut.GetAllAsync("0", "20", string.Empty, "asc", false);
Assert.AreEqual(result.Count(), 10);
Assert.AreEqual(result.Any(b => b.IsDeleted == true), false);
}
}
public async Task ReturnBarDTO_WhenGetSuccesfull()
{
//Arrange
var options = Utils.GetOptions(nameof(ReturnBarDTO_WhenGetSuccesfull));
var record = new Bar()
{
Name = "BestBar",
Rating = 4,
TimesRated = 1,
ImageSrc = null,
IsDeleted = false,
Address = "Галичица 17.",
Country = "България.",
District = "Лозенец.",
Email = "*****@*****.**",
Phone = "088888888.",
Town = "София.",
LocationId = null,
};
using (var context = new BCcontext(options))
{
await context.Bars.AddAsync(record);
await context.SaveChangesAsync();
}
var mockMapper = new Mock <IBarMapper>();
mockMapper.Setup((x) => x.MapEntityToDTO(It.IsAny <Bar>()))
.Returns((Bar b) => new BarDTO()
{
Id = b.Id,
Name = b.Name,
Rating = b.Rating,
TimesRated = b.TimesRated,
ImageSrc = b.ImageSrc,
IsDeleted = b.IsDeleted,
Address = b.Address,
Country = b.Country,
District = b.District,
Email = b.Email,
LocationId = b.LocationId,
Phone = b.Phone,
Town = b.Town
});
var http = new Mock <IHttpClientFactory>();
var coctailMapper = new Mock <ICocktailMapper>();
//Act & Assert
using (var context = new BCcontext(options))
{
var sut = new BarsService(context, mockMapper.Object, http.Object, coctailMapper.Object);
var dbResult = await context.Bars.FirstOrDefaultAsync(b => b.Name == "BestBar");
var result = await sut.GetAsync(dbResult.Id);
Assert.IsInstanceOfType(result, typeof(BarDTO));
}
}
private static async Task SeedIngredientsAsync(BCcontext context)
{
if (context.Ingredients.Any())
{
return;
}
var nonAlcoholics = new List <string>()
{
"Agave syrup",
"Almond syrup",
"Apple juice",
"Basil leaves",
"Black pepper",
"Cranberry juice (red)",
"Cream",
"Coca-Cola",
"Crème de cassis",
"Egg white",
"Espresso coffee (freshly made)",
"Fresh mint leaves/sprigs",
"Ginger (fresh root)",
"Grapefruit juice (pink)",
"Honey sugar syrup",
"Lemon juice",
"Lime juice",
"Lime slice",
"Maple syrup",
"Milk",
"Orange bitters",
"Orange juice",
"Passion fruit (fresh)",
"Passion fruit syrup",
"Pineapple juice",
"Pomegranate (grenadine) syrup",
"Raspberries (fresh)",
"Runny honey",
"Soda (club soda)",
"Sprite",
"Strawberries (fresh)",
"Sugar syrup",
"Tonic water",
"Vanilla sugar syrup",
"White crème de menthe",
};
foreach (var item in nonAlcoholics)
{
await context.Ingredients.AddAsync(new Ingredient()
{
Name = item,
IsAlcoholic = false,
//TODO: Should we initialize the collection of cocktails?
});
}
var alcoholics = new List <string>()
{
"Absinthe",
"Aged rum (+7 year old)",
"Amaretto liqueur",
"Apple schnapps liqueur",
"Apricot brandy liqueur",
"Black raspberry liqueur",
"Blended Scotch whisky",
"Blue curaçao liqueur",
"Bourbon whiskey",
"Brut champagne",
"Bénédictine D.O.M. liqueur",
"Calvados apple brandy",
"Campari Bitter",
"Chartreuse Vert (green)",
"Cherry brandy liqueur",
"Citrus flavoured vodka",
"Coconut rum liqueur",
"Coffee liqueur",
"Cognac V.S.O.P.",
"Crème de banane liqueur",
"Dark crème de cacao liqueur",
"Drambuie liqueur",
"Dry vermouth",
"Elderflower liqueur",
"Falernum liqueur",
"Galliano L'Autentico liqueur",
"Ginger ale",
"Ginger beer",
"Ginger liqueur",
"Golden rum",
"Grand Marnier liqueur",
"Hazelnut liqueur",
"Irish cream liqueur",
"Islay single malt Scotch whisky",
"Light white rum",
"London dry gin",
"Maraschino liqueur",
"Melon liqueur (green)",
"Navy rum",
"Peach Schnapps liqueur",
"Port wine",
"Prosecco sparkling wine",
"Sake",
"Southern Comfort liqueur",
"Straight rye whiskey",
"Sweet vermouth",
"Tequila (reposado)",
"Triple sec liqueur",
"Vanilla infused vodka",
"Vodka raspberry flavoured",
"Vodka",
"White crème de cacao liqueur",
"White wine (Sauvignon Blanc)",
"Żubrówka bison grass vodka"
};
foreach (var item in alcoholics)
{
await context.Ingredients.AddAsync(new Ingredient()
{
Name = item,
IsAlcoholic = true,
});
}
await context.SaveChangesAsync();
}
public async Task GetRightComments_Successfuly()
{
var testCocktailName = "TestCocktailName";
var testUserName = "******";
var options = Utils.GetOptions(nameof(GetRightComments_Successfuly));
var testUser = new User()
{
Id = Utils.MySampleGuid(),
UserName = testUserName,
};
var testUser2 = new User()
{
Id = Utils.MySampleGuid2(),
UserName = testUserName,
};
var testCocktail = new Cocktail()
{
Id = Utils.MySampleGuid3(),
Name = testCocktailName,
};
var testComment = new CocktailUserComment()
{
UserId = testUser.Id,
User = testUser,
CocktailId = testCocktail.Id,
Cocktail = testCocktail,
Text = "Comment text here.",
};
var testComment2 = new CocktailUserComment()
{
UserId = testUser2.Id,
User = testUser2,
CocktailId = testCocktail.Id,
Cocktail = testCocktail,
Text = "Comment text here.2",
};
var mockMapper = new Mock <ICocktailCommentMapper>();
mockMapper.Setup(x => x.MapDTOToEntity(It.IsAny <CocktailUserCommentDTO>()))
.Returns((CocktailUserCommentDTO x) => new CocktailUserComment()
{
CocktailId = x.CocktailId,
UserId = x.UserId,
Text = x.Text
});
mockMapper.Setup(x => x.MapEntityToDTO(It.IsAny <CocktailUserComment>()))
.Returns((CocktailUserComment x) => new CocktailUserCommentDTO()
{
CocktailId = x.CocktailId,
CocktailName = x.Cocktail.Name,
UserId = x.UserId,
UserName = x.User.UserName,
Text = x.Text
});
using (var arrangeContext = new BCcontext(options))
{
await arrangeContext.Users.AddAsync(testUser);
await arrangeContext.Users.AddAsync(testUser2);
await arrangeContext.Cocktails.AddAsync(testCocktail);
await arrangeContext.CocktailComments.AddAsync(testComment);
await arrangeContext.CocktailComments.AddAsync(testComment2);
await arrangeContext.SaveChangesAsync();
}
//Act & Assert
using (var context = new BCcontext(options))
{
var sut = new CocktailCommentsService(context, mockMapper.Object);
Assert.IsNotNull(context.Cocktails
.Include(x => x.Comments)
.FirstOrDefault(x => x.Name == testCocktailName)
.Comments.FirstOrDefault());
Assert.AreEqual(2, context.CocktailComments.Count());
//Act
var result = await sut.GetAllAsync(testCocktail.Id, "0", "12");
//Assert
Assert.IsNotNull(result);
//Does not change other
Assert.AreEqual(1, context.Cocktails.Count());
Assert.AreEqual(2, context.Users.Count());
Assert.AreEqual(2, context.CocktailComments.Count());
//Correct comments
Assert.AreEqual(testCocktail.Id, result.ToList()[0].CocktailId);
Assert.AreEqual(testUser.Id, result.ToList()[0].UserId);
Assert.AreEqual(testCocktail.Id, result.ToList()[1].CocktailId);
Assert.AreEqual(testUser2.Id, result.ToList()[1].UserId);
Assert.AreEqual(testComment.Text, result.ToList()[0].Text);
Assert.AreEqual(testComment2.Text, result.ToList()[1].Text);
}
}
public async Task DeleteCocktailComment_Successfuly()
{
var testBarName = "TestBarName";
var testUserName = "******";
var options = Utils.GetOptions(nameof(DeleteCocktailComment_Successfuly));
var testUser = new User()
{
Id = Utils.MySampleGuid(),
UserName = testUserName,
};
var testUser2 = new User()
{
Id = Utils.MySampleGuid2(),
UserName = testUserName,
};
var testBar = new Bar()
{
Id = Utils.MySampleGuid3(),
Name = testBarName,
};
var testComment = new BarUserComment()
{
UserId = testUser.Id,
User = testUser,
BarId = testBar.Id,
Bar = testBar,
Text = "Comment text here.",
};
var testComment2 = new BarUserComment()
{
UserId = testUser2.Id,
User = testUser2,
BarId = testBar.Id,
Bar = testBar,
Text = "Comment text here.2",
};
var mockMapper = new Mock <IBarUserCommentMapper>();
mockMapper.Setup(x => x.MapDTOToEntity(It.IsAny <BarUserCommentDTO>()))
.Returns((BarUserCommentDTO x) => new BarUserComment()
{
BarId = x.BarId,
UserId = x.UserId,
Text = x.Text
});
mockMapper.Setup(x => x.MapEntityToDTO(It.IsAny <BarUserComment>()))
.Returns((BarUserComment x) => new BarUserCommentDTO()
{
BarId = x.BarId,
BarName = x.Bar.Name,
UserId = x.UserId,
UserName = x.User.UserName,
Text = x.Text
});
using (var arrangeContext = new BCcontext(options))
{
await arrangeContext.Users.AddAsync(testUser);
await arrangeContext.Users.AddAsync(testUser2);
await arrangeContext.Bars.AddAsync(testBar);
await arrangeContext.BarComments.AddAsync(testComment);
await arrangeContext.BarComments.AddAsync(testComment2);
await arrangeContext.SaveChangesAsync();
}
//Act & Assert
using (var context = new BCcontext(options))
{
var sut = new BarUserCommentsService(context, mockMapper.Object);
Assert.IsNotNull(context.Bars
.Include(x => x.Comments)
.FirstOrDefault(x => x.Name == testBarName)
.Comments.FirstOrDefault());
Assert.AreEqual(2, context.BarComments.Count());
//Act
var result = await sut.DeleteAsync(testBar.Id, testUser.Id);
//Assert
Assert.IsTrue(result);
Assert.AreEqual(1, context.BarComments.Count());
Assert.AreEqual(testComment2.Text, context.BarComments.ToList()[0].Text);
Assert.IsNotNull(context.Bars.FirstOrDefault());
Assert.IsNotNull(context.Users.FirstOrDefault());
}
}
