public async Task AddIngredientsToCocktail_True_whenValid()
{
var options = Utils.GetOptions(nameof(AddIngredientsToCocktail_True_whenValid));
var cocktail = new Cocktail()
{
Id = Utils.MySampleGuid(),
};
var ingredientId = Utils.MySampleGuid2();
var mockMapper = new Mock <ICocktailMapper>();
var mockBarMapper = new Mock <IBarMapper>();
using (var arrangeContext = new BCcontext(options))
{
}
using (var context = new BCcontext(options))
{
var sut = new CocktailsService(context, mockMapper.Object, mockBarMapper.Object);
var result = await sut.AddIngredientsToCocktail(cocktail, ingredientId, 2);
Assert.IsTrue(result);
}
}
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);
}
}
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 BarsService(BCcontext context, IBarMapper mapper, IHttpClientFactory httpClient, ICocktailMapper cocktailMapper)
{
_context = context ?? throw new ArgumentNullException(nameof(context));
_mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));
_clientFactory = httpClient ?? throw new ArgumentNullException(nameof(mapper));
_cocktailMapper = cocktailMapper ?? throw new ArgumentNullException(nameof(mapper));
}
public async Task ReturnFalse_when_NotValidIngredientIDAsync()
{
//Arrange
var options = Utils.GetOptions("ReturnFalse_when_NotValidIngredientIDAsync");
var entity = new Ingredient
{
Name = "Lime",
IsAlcoholic = false
};
var mockMapper = new Mock <IIngredientMapper>();
using (var arrangeContext = new BCcontext(options))
{
arrangeContext.Ingredients.Add(entity);
arrangeContext.SaveChanges();
}
//Act & Assert
using (var context = new BCcontext(options))
{
var sut = new IngredientsService(context, mockMapper.Object);
var result = await sut.DeleteAsync(Utils.MySampleGuid());
Assert.IsFalse(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);
}
}
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 UsersService(BCcontext context
, IUserMapper mapper
, ICocktailCommentMapper cocktailCommentMapper)
{
this._context = context ?? throw new ArgumentNullException(nameof(context));
this._mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));
this._cocktailCommentMapper = cocktailCommentMapper ?? throw new ArgumentNullException(nameof(cocktailCommentMapper));
}
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 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 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 CocktailsService(BCcontext context,
ICocktailMapper mapper,
IBarMapper barMapper
)
{
this._context = context ?? throw new ArgumentNullException(nameof(context));
this._mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));
this._barMapper = barMapper ?? throw new ArgumentNullException(nameof(barMapper));
//this._logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
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 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 DeleteCocktail_ShouldReturnTrue_when_ValidAsync()
{
//Arrange
var options = Utils.GetOptions(nameof(DeleteCocktail_ShouldReturnTrue_when_ValidAsync));
var entity = new Cocktail
{
Id = Utils.MySampleGuid(),
Name = "Mohito",
IsDeleted = false,
};
var mockMapper = new Mock <ICocktailMapper>();
mockMapper.Setup(x => x.MapDTOToEntity(It.IsAny <CocktailDTO>()))
.Returns((CocktailDTO x) => new Cocktail()
{
Id = x.Id,
Name = x.Name,
TimesRated = x.TimesRated,
});
mockMapper.Setup(x => x.MapEntityToDTO(It.IsAny <Cocktail>()))
.Returns((Cocktail x) => new CocktailDTO()
{
Id = x.Id,
Name = x.Name,
TimesRated = x.TimesRated,
});
var mockBarMapper = new Mock <IBarMapper>();
using (var arrangeContext = new BCcontext(options))
{
arrangeContext.Cocktails.Add(entity);
arrangeContext.SaveChanges();
}
//Act & Assert
using (var context = new BCcontext(options))
{
var sut = new CocktailsService(context, mockMapper.Object, mockBarMapper.Object);
var result = await sut.DeleteAsync(Utils.MySampleGuid());
Assert.IsTrue(result);
}
}
public async Task CocktailExistsByName_False_whenNotExisting()
{
var options = Utils.GetOptions(nameof(CocktailExistsByName_False_whenNotExisting));
var mockMapper = new Mock <ICocktailMapper>();
var mockBarMapper = new Mock <IBarMapper>();
//Act and Assert
using (var context = new BCcontext(options))
{
var sut = new CocktailsService(context, mockMapper.Object, mockBarMapper.Object);
var result = await sut.CocktailExistsByNameAsync("TestName");
Assert.IsFalse(result);
}
}
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 void ThrowArgumentNullException_IfNoCocktailCommentMapperforUser()
{
//Arrange
var options = Utils.GetOptions(nameof(ThrowArgumentNullException_IfNoCocktailCommentMapperforUser));
using (var context = new BCcontext(options))
{
}
var mockMapper = new Mock <IUserMapper>();
var coctailMapper = new Mock <ICocktailCommentMapper>();
//Act & Assert
using (var context = new BCcontext(options))
{
Assert.ThrowsException <ArgumentNullException>(() => new UsersService(context, mockMapper.Object, null));
}
}
public void ThrowArgumentNullException_IfNoCocktailMapperforBar()
{
//Arrange
var options = Utils.GetOptions(nameof(ThrowArgumentNullException_IfNoCocktailMapperforBar));
using (var context = new BCcontext(options))
{
}
var mockMapper = new Mock <IBarMapper>();
var http = new Mock <IHttpClientFactory>();
//Act & Assert
using (var context = new BCcontext(options))
{
Assert.ThrowsException <ArgumentNullException>(() => new BarsService(context, mockMapper.Object, http.Object, null));
}
}
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 void DeleteCocktail_ReturnFalse_when_NotValidID()
{
//Arrange
var options = Utils.GetOptions("DeleteCocktail_ReturnFalse_when_NotValidID");
//var entity = new
var mockMapper = new Mock <ICocktailMapper>();
var mockBarMapper = new Mock <IBarMapper>();
//Act & Assert
using (var context = new BCcontext(options))
{
var sut = new CocktailsService(context, mockMapper.Object, mockBarMapper.Object);
var result = sut.DeleteAsync(Utils.MySampleGuid()).Result;
Assert.IsFalse(result);
}
}
//private readonly IBarCommentMapper _barCommentMapper;
//private readonly IBarMapper _barMapper;
public UserInteractionsService(BCcontext context
, IUserMapper userMapper
, ICocktailCommentMapper cocktailCommentMapper
, IUsersService usersService
, ICocktailsService cocktailsService
, ICocktailMapper cocktailMapper
)
{
this._context = context ?? throw new ArgumentNullException(nameof(context));
this._userMapper = userMapper ?? throw new ArgumentNullException(nameof(userMapper));
this._cocktailCommentMapper = cocktailCommentMapper ?? throw new ArgumentNullException(nameof(cocktailCommentMapper));
this._usersService = usersService ?? throw new ArgumentNullException(nameof(usersService));
this._cocktailsService = cocktailsService ?? throw new ArgumentNullException(nameof(cocktailsService));
this._cocktailMapper = cocktailMapper ?? throw new ArgumentNullException(nameof(cocktailMapper));
//this._barCommentMapper = barCommentMapper ?? throw new ArgumentNullException(nameof(barCommentMapper));
//this._barMapper = barMapper ?? throw new ArgumentNullException(nameof(barMapper));
//throw new NotImplementedException(" Service for Commenting / Rating Cocktails/Bars");
}
public async System.Threading.Tasks.Task ReturnCorrectIngredient_when_ValidAsync()
{
//Arrange
var options = Utils.GetOptions("ReturnCorrectIngredient_when_ValidAsync");
var entity = new Ingredient
{
Id = Utils.MySampleGuid(),
Name = "Lime",
IsAlcoholic = false
};
var mockMapper = new Mock <IIngredientMapper>();
mockMapper.Setup((x) => x.MapEntityToDTO(It.IsAny <Ingredient>()))
.Returns(new IngredientDTO()
{
Id = entity.Id,
Name = entity.Name,
IsAlcoholic = entity.IsAlcoholic,
});
using (var arrangeContext = new BCcontext(options))
{
arrangeContext.Ingredients.Add(entity);
arrangeContext.SaveChanges();
}
//Act & Assert
using (var context = new BCcontext(options))
{
var sut = new IngredientsService(context, mockMapper.Object);
var dbResult = await context.Ingredients.FirstOrDefaultAsync(x => x.Name == entity.Name);
var result = await sut.GetAsync(dbResult.Id);
Assert.AreEqual(dbResult.Id, result.Id);
Assert.AreEqual(dbResult.Name, result.Name);
Assert.AreEqual(dbResult.IsAlcoholic, result.IsAlcoholic);
}
}
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);
}
}
public void CocktailExists_False_whenNotExisting()
{
var options = Utils.GetOptions(nameof(CocktailExists_False_whenNotExisting));
var testCocktailId = Utils.MySampleGuid();
var mockMapper = new Mock <ICocktailMapper>();
var mockBarMapper = new Mock <IBarMapper>();
using (var arrangeContext = new BCcontext(options))
{
}
//Act and Assert
using (var context = new BCcontext(options))
{
var sut = new CocktailsService(context, mockMapper.Object, mockBarMapper.Object);
var result = sut.CocktailExists(testCocktailId);
Assert.IsFalse(result);
}
}
public async Task ReturnNull_noSearch_whenNoCocktails()
{
var options = Utils.GetOptions(nameof(ReturnNull_noSearch_whenNoCocktails));
var mockMapper = new Mock <ICocktailMapper>();
var mockBarMapper = new Mock <IBarMapper>();
using (var arrangeContext = new BCcontext(options))
{
}
using (var actContext = new BCcontext(options))
{
var sut = new CocktailsService(actContext, mockMapper.Object, mockBarMapper.Object);
var cocktail = await sut.GetAllAsync("0", "12", "", "", false);
Assert.IsNotNull(cocktail);
Assert.AreEqual(0, actContext.Cocktails.Count());
}
}
public async Task ThrowArgumentNullException_WhenArgumentNull()
{
//Arrange
var options = Utils.GetOptions("RecordsBar_WhenBarDoesntExist");
using (var context = new BCcontext(options))
{
}
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);
await Assert.ThrowsExceptionAsync <ArgumentNullException>(async() => await sut.CreateAsync(null));
}
}
public async Task ReturnFalse_WhenBarDoesntExist()
{
//Arrange
var options = Utils.GetOptions(nameof(ReturnFalse_WhenBarDoesntExist));
using (var context = new BCcontext(options))
{
}
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 result = await sut.BarExistsByName("BestBar");
Assert.AreEqual(result, false);
}
}
public async Task ThrowArgumentException_IfParameterIncorect()
{
//Arrange
var options = Utils.GetOptions(nameof(ThrowArgumentException_IfParameterIncorect));
using (var context = new BCcontext(options))
{
}
var mockMapper = new Mock <IUserMapper>();
var coctailMapper = new Mock <ICocktailCommentMapper>();
//Act & Assert
using (var context = new BCcontext(options))
{
var sut = new UsersService(context, mockMapper.Object, coctailMapper.Object);
await Assert.ThrowsExceptionAsync <ArgumentException>(async() => await sut.GetAllAsync("a", "10", string.Empty));
await Assert.ThrowsExceptionAsync <ArgumentException>(async() => await sut.GetAllAsync("0", "a", string.Empty));
}
}
public async Task ReturnNull_WhenBarDoesntExist()
{
//Arrange
var options = Utils.GetOptions(nameof(ReturnNull_WhenBarDoesntExist));
using (var context = new BCcontext(options))
{
}
var bar = new BarDTO()
{
Name = "BestBarAgain",
Rating = 4,
TimesRated = 1,
ImageSrc = null,
IsDeleted = false,
Address = "Галичица 17",
Country = "България",
District = "Лозенец",
Email = "*****@*****.**",
Phone = "088888888",
Town = "София"
};
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 result = await sut.UpdateAsync(Guid.NewGuid(), bar);
Assert.AreEqual(result, null);
}
}
