public async Task MakeInstance_OfTypeIngredientService_WhenValidValuesPassed()
{
var options = TestUtils.GetOptions(nameof(MakeInstance_OfTypeIngredientService_WhenValidValuesPassed));
using (var assertContext = new CMContext(options))
{
var sut = new IngredientServices(assertContext);
Assert.IsInstanceOfType(sut, typeof(IngredientServices));
}
}
public void ReturnFalseIfSuchIngredientDoesntExist()
{
var options = TestUtilities.GetOptions(nameof(ReturnFalseIfSuchIngredientDoesntExist));
//act & assert
using (var assertContext = new CocktailDB(options))
{
var sut = new IngredientServices(assertContext);
Assert.IsFalse(sut.IngredientWithThatNameExists("test").GetAwaiter().GetResult());
}
}
public async Task Throw_MagicExeption_IngredientWhitSuchId_DoesNotExist()
{
var options = TestUtils.GetOptions(nameof(Throw_MagicExeption_IngredientWhitSuchId_DoesNotExist));
using (var assertContext = new CMContext(options))
{
var sut = new IngredientServices(assertContext);
var ex = await Assert.ThrowsExceptionAsync <MagicException>(
async() => await sut.GetIngredientById("ddd"));
}
}
public async Task Throw_MagicExeption_WhenNullIngredientOccurs()
{
var options = TestUtils.GetOptions(nameof(Throw_MagicExeption_WhenNullIngredientOccurs));
using (var assertContext = new CMContext(options))
{
var sut = new IngredientServices(assertContext);
var ex = await Assert.ThrowsExceptionAsync <MagicException>(
async() => await sut.GetIngredientIdByNameAsync("Name"));
}
}
public async Task Throw_MagicExeption_WhenNullIngredientDto_Passed()
{
var options = TestUtils.GetOptions(nameof(Throw_MagicExeption_WhenNullIngredientDto_Passed));
using (var assertContext = new CMContext(options))
{
var sut = new IngredientServices(assertContext);
var ex = await Assert.ThrowsExceptionAsync <MagicException>(
async() => await sut.EditIngredienAsync(null));
}
}
public async Task Throw_MagicExeption_WhenIngredientWithSuchId_DoesnotExist()
{
var options = TestUtils.GetOptions(nameof(Throw_MagicExeption_WhenIngredientWithSuchId_DoesnotExist));
using (var assertContext = new CMContext(options))
{
var sut = new IngredientServices(assertContext);
var ex = await Assert.ThrowsExceptionAsync <MagicException>(
async() => await sut.DeleteIngredientAsync("lll"));
}
}
public async Task ReturnLastPageNotDeletedIngredients()
{
var ingredientFactoryMock = new Mock <IIngredientFactory>();
var ingredient1Name = "Name1";
var ingredient2Name = "Name2";
var ingredient3Name = "Name3";
var deletedIngredientName = "Deleted";
var ingredientUnit = "Unit";
var ingredient1 = new Ingredient
{
Name = ingredient1Name,
Unit = ingredientUnit
};
var ingredient2 = new Ingredient
{
Name = ingredient2Name,
Unit = ingredientUnit
};
var ingredient3 = new Ingredient
{
Name = ingredient3Name,
Unit = ingredientUnit
};
var deletedIngredient = new Ingredient
{
Name = deletedIngredientName,
Unit = ingredientUnit,
IsDeleted = true
};
var options = TestUtilities.GetOptions(nameof(ReturnLastPageNotDeletedIngredients));
using (var arrangeContext = new CocktailMagicianDb(options))
{
arrangeContext.Ingredients.AddRange(new List <Ingredient> {
ingredient1, ingredient2, ingredient3, deletedIngredient
});
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new CocktailMagicianDb(options))
{
var sut = new IngredientServices(assertContext, ingredientFactoryMock.Object);
var listOfIngredients = await sut.GetAllPagedDTOAsync(2, 2);
Assert.AreEqual(1, listOfIngredients.Count());
Assert.IsFalse(listOfIngredients.Any(i => i.Name == deletedIngredientName));
}
}
public async Task Throw_CorrectMagicMsg_IngredientWhitSuchId_DoesNotExist()
{
var options = TestUtils.GetOptions(nameof(Throw_CorrectMagicMsg_IngredientWhitSuchId_DoesNotExist));
using (var assertContext = new CMContext(options))
{
var sut = new IngredientServices(assertContext);
var ex = await Assert.ThrowsExceptionAsync <MagicException>(
async() => await sut.GetIngredientById("ddd"));
Assert.AreEqual("Ingredient cannot be null!", ex.Message);
}
}
public async Task Throw_CorrectMagicMsg_WhenNullIngredientDtoPassed()
{
var options = TestUtils.GetOptions(nameof(Throw_MagicMsg_WhenNullIngredientDtoPassed));
using (var assertContext = new CMContext(options))
{
var sut = new IngredientServices(assertContext);
var ex = await Assert.ThrowsExceptionAsync <MagicException>(
async() => await sut.AddIngredient(null));
Assert.AreEqual("IngredientDto cannot be null!", ex.Message);
}
}
public void CreateNewInstanceOfIngredient()
{
// Arrange
var options = TestUtilities.GetOptions(nameof(CreateNewInstanceOfIngredient));
// Act, Assert
using (var assertContext = new CocktailDB(options))
{
var sut = new IngredientServices(assertContext);
var name = "Rum";
var type = "alcohol";
var ingredient = sut.AddAsync(name, type).GetAwaiter().GetResult();
Assert.IsInstanceOfType(ingredient, typeof(Ingredient));
}
}
Return_EmptyIListOf_IfThereIsNoIngredients_WhenPageNumberPassed()
{
var options = TestUtils.GetOptions
(nameof(Return_EmptyIListOf_IfThereIsNoIngredients_WhenPageNumberPassed));
using (var assertContext = new CMContext(options))
{
var sut = new IngredientServices(assertContext);
var result = await sut.GetTenIngredientsAsync(2);
Assert.AreEqual(0, result.Count);
Assert.IsInstanceOfType(result, typeof(IList <IngredientDTO>));
}
}
public async Task Return_EmptyList_IfThereAreNoIngredients()
{
var options = TestUtils.GetOptions
(nameof(Return_EmptyList_IfThereAreNoIngredients));
using (var assertContext = new CMContext(options))
{
var sut = new IngredientServices(assertContext);
var result = await sut.GetAllIngredients();
Assert.IsInstanceOfType(result, typeof(IList <IngredientDTO>));
Assert.AreEqual(result.Count, 0);
}
}
public void ShouldReturnEmptyCollectionIfNoIngredientsAreFound()
{
// Arrange
var options = TestUtilities.GetOptions(nameof(ShouldReturnEmptyCollectionIfNoIngredientsAreFound));
// Act, Assert
using (var assertContext = new CocktailDB(options))
{
var sut = new IngredientServices(assertContext);
var result = sut.SearchIngredientsAsync("e").GetAwaiter().GetResult();
Assert.IsTrue(result.Count == 0);
}
}
public async Task Return_EmptyICollection_IfThereIsNoIngredients()
{
var options = TestUtils.GetOptions
(nameof(Return_EmptyICollection_IfThereIsNoIngredients));
using (var assertContext = new CMContext(options))
{
var sut = new IngredientServices(assertContext);
var result = await sut.GetImagesForHpAsync();
Assert.AreEqual(0, result.ToList().Count());
Assert.IsInstanceOfType(result, typeof(ICollection <String>));
}
}
public void ReturnFalseIfTheIngredientIsNotUsedInAnyCocktail()
{
// Arrange
var options = TestUtilities.GetOptions(nameof(ReturnFalseIfTheIngredientIsNotUsedInAnyCocktail));
// Act, Assert
using (var assertContext = new CocktailDB(options))
{
var sut = new IngredientServices(assertContext);
var name = "Rum";
var type = "alcohol";
var ingredient = sut.AddAsync(name, type).GetAwaiter().GetResult();
var result = sut.IsIngredientUsedAsync(ingredient.ID).GetAwaiter().GetResult();
Assert.IsFalse(result);
}
}
public void AddTheIngredientToTheDBSetCOrrectly()
{
// Arrange
var options = TestUtilities.GetOptions(nameof(AddTheIngredientToTheDBSetCOrrectly));
// Act, Assert
using (var assertContext = new CocktailDB(options))
{
var sut = new IngredientServices(assertContext);
var name = "Rum";
var type = "alcohol";
var ingredient = sut.AddAsync(name, type).GetAwaiter().GetResult();
Assert.IsTrue(assertContext.Ingredients.Contains(ingredient));
}
}
public async Task Return_IngredientName_WhenValidIdPassed()
{
var options = TestUtils.GetOptions(nameof(Return_IngredientName_WhenValidIdPassed));
using (var assertContext = new CMContext(options))
{
var sut = new IngredientServices(assertContext);
assertContext.Ingredients.Add(new Ingredient {
Id = "1", Name = "target"
});
await assertContext.SaveChangesAsync();
var result = await sut.GetIngredientNameById("1");
Assert.AreEqual("target", result);
}
}
public async Task ThrowsException_WhenIngredientIsPartOfCocktail()
{
var ingredientFactoryMock = new Mock <IIngredientFactory>();
var ingredientName = "Name";
var ingredientUnit = "Unit";
var ingredient = new Ingredient
{
Name = ingredientName,
Unit = ingredientUnit,
};
var cocktailNameTest = "TestName";
var imageURLTest = "https://www.google.com/";
var cocktail = new Cocktail
{
Name = cocktailNameTest,
ImagePath = imageURLTest,
};
var ingredientQuantity = 0.5;
var options = TestUtilities.GetOptions(nameof(ThrowsException_WhenIngredientIsPartOfCocktail));
using (var arrangeContext = new CocktailMagicianDb(options))
{
arrangeContext.CocktailIngredients.Add(new CocktailIngredient
{
Cocktail = cocktail,
Ingredient = ingredient,
Quatity = ingredientQuantity
});
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new CocktailMagicianDb(options))
{
var ingredientId = await assertContext.Ingredients.Where(i => i.Name == ingredientName).Select(i => i.Id).FirstAsync();
var sut = new IngredientServices(assertContext, ingredientFactoryMock.Object);
await Assert.ThrowsExceptionAsync <InvalidOperationException>(() => sut.DeleteAsync(ingredientId));
}
}
public async Task GetCocktailIngredients_Returns_WhenParamIsValid()
{
//Arrange
var options = Utils.GetOptions(nameof(GetCocktailIngredients_Returns_WhenParamIsValid));
var ingredient = new Ingredient {
Id = Guid.NewGuid(), Name = "Vodka"
};
var cocktail = new Cocktail {
Id = Guid.NewGuid(), Name = "Manhattan"
};
var cocktail2 = new Cocktail {
Id = Guid.NewGuid(), Name = "Margarita"
};
var cocktailIngredient = new CocktailIngredient {
IngredientId = ingredient.Id, CocktailId = cocktail.Id
};
var cocktailIngredient2 = new CocktailIngredient {
IngredientId = ingredient.Id, CocktailId = cocktail2.Id
};
using (var arrangeContext = new CMContext(options))
{
await arrangeContext.Ingredients.AddAsync(ingredient);
await arrangeContext.Cocktails.AddRangeAsync(cocktail, cocktail2);
await arrangeContext.CocktailIngredients.AddRangeAsync(cocktailIngredient, cocktailIngredient2);
await arrangeContext.SaveChangesAsync();
}
//Act, Assert
using (var assertContext = new CMContext(options))
{
var sut = new IngredientServices(assertContext);
var result = await sut.GetCocktailIngredients(cocktail.Id);
Assert.AreEqual(cocktail.Id, result.ToList()[0].CocktailId);
Assert.AreEqual(ingredient.Id, result.ToList()[0].IngredientId);
Assert.AreEqual(ingredient.Name, result.ToList()[0].Ingredient.Name);
Assert.AreEqual(cocktail.Name, result.ToList()[0].Cocktail.Name);
Assert.IsInstanceOfType(result, typeof(ICollection <CocktailIngredientDTO>));
}
}
public void DeleteTheDesiredIngredient()
{
// Arrange
var options = TestUtilities.GetOptions(nameof(DeleteTheDesiredIngredient));
// Act, Assert
using (var assertContext = new CocktailDB(options))
{
var sut = new IngredientServices(assertContext);
var name = "Rum";
var type = "alcohol";
var ingredient = sut.AddAsync(name, type).GetAwaiter().GetResult();
sut.DeleteAsync(ingredient.Id).GetAwaiter().GetResult();
Assert.IsNull(assertContext.Ingredients.Find(ingredient.Id));
}
}
public async Task ReturnId_WhenValidIngredientName_Passed()
{
var options = TestUtils.GetOptions(nameof(ReturnId_WhenValidIngredientName_Passed));
using (var assertContext = new CMContext(options))
{
var sut = new IngredientServices(assertContext);
assertContext.Ingredients.Add(new Ingredient {
Id = "33", Name = "water"
});
await assertContext.SaveChangesAsync();
var result = await sut.GetIngredientIdByNameAsync("water");
Assert.AreEqual("33", result);
}
}
public void ReturnCollectionOfNullElementsIfThereAreNoMatches()
{
// Arrange
var options = TestUtilities.GetOptions(nameof(ReturnCollectionOfNullElementsIfThereAreNoMatches));
// Act, Assert
using (var assertContext = new CocktailDB(options))
{
var sut = new IngredientServices(assertContext);
var names = new List <string> {
"Rum", "Rum2"
};
var result = sut.GetMultipleIngredientsByNameAsync(names).GetAwaiter().GetResult();
Assert.IsTrue(result.All(e => e == null));
}
}
public void ReturnCorrectIngredient()
{
// Arrange
var options = TestUtilities.GetOptions(nameof(ReturnCorrectIngredient));
// Act, Assert
using (var assertContext = new CocktailDB(options))
{
var sut = new IngredientServices(assertContext);
var name = "Rum";
var type = "alcohol";
var ingredient = sut.AddAsync(name, type).GetAwaiter().GetResult();
var result = sut.GetAsync(ingredient.ID).GetAwaiter().GetResult();
Assert.AreEqual(ingredient, result);
}
}
public async Task Throw_CorrectMagicExeption_IfYouTryToDeleteIngredient_WichIsPartOfCocktail()
{
var options = TestUtils.GetOptions
(nameof(Throw_CorrectMagicExeption_IfYouTryToDeleteIngredient_WichIsPartOfCocktail));
using (var arrangeContext = new CMContext(options))
{
//1
arrangeContext.Cocktails.Add(
new Cocktail
{
Id = "1",
Name = "Cocktail"
});
arrangeContext.Ingredients.Add(
new Ingredient
{
Id = "1",
Name = "target1",
CocktailComponents = new List <CocktailComponent>
{
new CocktailComponent
{
Id = "1",
Name = "vodka",
IngredientId = "1",
CocktailId = "1"
}
}
});
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new CMContext(options))
{
var sut = new IngredientServices(assertContext);
var ex = await Assert.ThrowsExceptionAsync <MagicException>(
async() => await sut.DeleteIngredientAsync("1"));
Assert.AreEqual("You cannot delete this ingredient", ex.Message);
}
}
public void ReturnTureIfSuchIngredientExists()
{
var options = TestUtilities.GetOptions(nameof(ReturnTureIfSuchIngredientExists));
var ingredient = new Ingredient
{
Id = 1,
Name = "test",
};
//act & assert
using (var assertContext = new CocktailDB(options))
{
var sut = new IngredientServices(assertContext);
assertContext.Ingredients.Add(ingredient);
assertContext.SaveChanges();
Assert.IsTrue(sut.IngredientWithThatNameExists(ingredient.Name).GetAwaiter().GetResult());
}
}
public void UpdateTheIngredientNameCorrectly()
{
// Arrange
var options = TestUtilities.GetOptions(nameof(UpdateTheIngredientNameCorrectly));
// Act, Assert
using (var assertContext = new CocktailDB(options))
{
var sut = new IngredientServices(assertContext);
var name = "Rum";
var type = "alcohol";
var ingredient = sut.AddAsync(name, type).GetAwaiter().GetResult();
var newName = "Test12";
sut.UpdateAsync(ingredient.ID, newName).GetAwaiter().GetResult();
Assert.AreEqual(newName, ingredient.Name);
}
}
public async Task AddIngredient_ToDb_WhenValidIngredientDtoPassed()
{
var options = TestUtils.GetOptions(nameof(AddIngredient_ToDb_WhenValidIngredientDtoPassed));
using (var arrangeContext = new CMContext(options))
{
var sut = new IngredientServices(arrangeContext);
await sut.AddIngredient(
new IngredientDTO
{
Name = "voda",
});
}
using (var assertContext = new CMContext(options))
{
Assert.AreEqual("voda", assertContext.Ingredients.First().Name);
}
}
public void ReturnCollectionOfCorrectIngredientsContainingTheSpecifiedChar()
{
// Arrange
var options = TestUtilities.GetOptions(nameof(ReturnCollectionOfCorrectIngredientsContainingTheSpecifiedChar));
// Act, Assert
using (var assertContext = new CocktailDB(options))
{
var sut = new IngredientServices(assertContext);
var name = "Rum";
var type = "alcohol";
var ingredient = sut.AddAsync(name, type).GetAwaiter().GetResult();
name = "Rum2";
var ingredient2 = sut.AddAsync(name, type).GetAwaiter().GetResult();
var result = sut.SearchIngredientsAsync("u").GetAwaiter().GetResult();
Assert.IsTrue(result.Count == 2 && result.Contains(ingredient) && result.Contains(ingredient));
}
}
public async Task AvailabilityAtCocktails_Returns_Correct()
{
//Arrange
var options = Utils.GetOptions(nameof(AvailabilityAtCocktails_Returns_Correct));
var cocktail = new Cocktail {
Id = Guid.NewGuid(), Name = "Cuba Libre"
};
var ingredient = new Ingredient {
Id = Guid.NewGuid(), Name = "Rum", Description = "Alcoholic spirit"
};
var cocktailIngredient = new CocktailIngredient {
CocktailId = cocktail.Id, IngredientId = ingredient.Id, IsDeleted = true
};
using (var arrangeContext = new CMContext(options))
{
await arrangeContext.Ingredients.AddAsync(ingredient);
await arrangeContext.Cocktails.AddAsync(cocktail);
await arrangeContext.CocktailIngredients.AddAsync(cocktailIngredient);
await arrangeContext.SaveChangesAsync();
}
//Act, Assert
using (var assertContext = new CMContext(options))
{
var sut = new IngredientServices(assertContext);
var result = await sut.AvailabilityAtCocktails(ingredient.Id);
Assert.AreEqual(0, result.Count);
Assert.IsInstanceOfType(result, typeof(ICollection <CocktailIngredientDTO>));
}
}
public async Task ReturnAllNotDeletedIngredientsCount()
{
var ingredientFactoryMock = new Mock <IIngredientFactory>();
var ingredientName = "Name";
var deletedIngredientName = "Deleted";
var ingredientUnit = "Unit";
var ingredient = new Ingredient
{
Name = ingredientName,
Unit = ingredientUnit
};
var deleteIngredient = new Ingredient
{
Name = deletedIngredientName,
Unit = ingredientUnit,
IsDeleted = true
};
var options = TestUtilities.GetOptions(nameof(ReturnAllNotDeletedIngredientsCount));
using (var arrangeContext = new CocktailMagicianDb(options))
{
arrangeContext.Ingredients.AddRange(new List <Ingredient> {
ingredient, deleteIngredient
});
await arrangeContext.SaveChangesAsync();
}
using (var assertContext = new CocktailMagicianDb(options))
{
var sut = new IngredientServices(assertContext, ingredientFactoryMock.Object);
var count = await sut.AllIngredientsCountAsync();
Assert.AreEqual(1, count);
}
}
