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 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 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 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 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 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 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);
}
}
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 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 UpdateCocktail_When_Valid()
{
var testCocktailName = "TestCocktailName";
var options = Utils.GetOptions(nameof(UpdateCocktail_When_Valid));
var entityCocktail = new Cocktail()
{
Id = Utils.MySampleGuid(),
Name = testCocktailName,
TimesRated = 3
};
var ingredient = new Ingredient()
{
Id = Utils.MySampleGuid3(),
IsAlcoholic = true,
};
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>();
var dto = new CocktailDTO()
{
Id = Utils.MySampleGuid(),
Name = "NewCocktailName",
IsAlcoholic = true,
TimesRated = 4,
Ingredients = new List <CocktailIngredientDTO>()
{
new CocktailIngredientDTO()
{
IngredientId = Utils.MySampleGuid3(),
Parts = 2
}
},
};
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 = await sut.UpdateAsync(Utils.MySampleGuid(), dto);
await actContext.SaveChangesAsync();
}
using (var assertContext = new BCcontext(options))
{
var cocktail = await assertContext.Cocktails
.FirstOrDefaultAsync(x => x.Id == Utils.MySampleGuid());
Assert.IsNotNull(cocktail);
Assert.AreEqual("NewCocktailName", cocktail.Name);
Assert.AreEqual(dto.TimesRated, cocktail.TimesRated);
}
}
