public void ThrowArgumentException_When_UpdatedBeerExists()
{
var options = Utils.GetOptions(nameof(ThrowArgumentException_When_UpdatedBeerExists));
var beerType = TestsModelsSeeder.SeedBeerType();
var brewery = TestsModelsSeeder.SeedBrewery();
var country = TestsModelsSeeder.SeedCountry();
var beer = TestsModelsSeeder.SeedBeer();
var beer2 = TestsModelsSeeder.SeedBeer2();
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.Countries.Add(country);
arrangeContext.Breweries.Add(brewery);
arrangeContext.BeerTypes.Add(beerType);
arrangeContext.Beers.Add(beer);
arrangeContext.Beers.Add(beer2);
arrangeContext.SaveChanges();
}
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new BeerServices(assertContext);
Assert.ThrowsException <ArgumentException>(() => sut.UpdateBeer(1, beer2.Name, beer2.Type.Name, beer2.Brewery.Name, 6));
}
}
public void ReturnCorrectList_WhenDataIsPresent()
{
var options = Utils.GetOptions(nameof(ReturnCorrectList_WhenDataIsPresent));
var beerType1 = TestsModelsSeeder.SeedBeerType();
var beerType2 = TestsModelsSeeder.SeedBeerType2();
var beerType3 = TestsModelsSeeder.SeedBeerType3();
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.BeerTypes.Add(beerType1);
arrangeContext.BeerTypes.Add(beerType2);
arrangeContext.BeerTypes.Add(beerType3);
arrangeContext.SaveChanges();
}
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new BeerTypeServices(assertContext);
var result = sut.GetAllBeerTypes().ToList();
Assert.AreEqual(3, result.Count);
Assert.AreEqual(beerType1.Name, result[0].Name);
Assert.AreEqual(beerType2.Name, result[1].Name);
Assert.AreEqual(beerType3.Name, result[2].Name);
}
}
public void ReturnCorrectList_WhenDataIsPresent()
{
var options = Utils.GetOptions(nameof(ReturnCorrectList_WhenDataIsPresent));
var userRole = TestsModelsSeeder.SeedUserRole();
var user1 = TestsModelsSeeder.SeedUser();
var user2 = TestsModelsSeeder.SeedUser2();
var user3 = TestsModelsSeeder.SeedUser3();
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.Roles.Add(userRole);
arrangeContext.Users.Add(user1);
arrangeContext.Users.Add(user2);
arrangeContext.Users.Add(user3);
arrangeContext.SaveChanges();
}
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new UserServices(assertContext);
var result = sut.GetAllUsers().ToList();
Assert.AreEqual(3, result.Count);
Assert.AreEqual(user1.UserName, result[0].UserName);
Assert.AreEqual(user2.UserName, result[1].UserName);
Assert.AreEqual(user3.UserName, result[2].UserName);
}
}
public void ReturnCorrectReview_When_ParamsValid()
{
var options = Utils.GetOptions(nameof(ReturnCorrectReview_When_ParamsValid));
var review = TestsModelsSeeder.SeedReview();
var beer = TestsModelsSeeder.SeedBeer();
var user = TestsModelsSeeder.SeedUser();
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.Add(review);
arrangeContext.Users.Add(user);
arrangeContext.Beers.Add(beer);
arrangeContext.SaveChanges();
}
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new ReviewServices(assertContext);
var result = sut.GetReview(1);
Assert.AreEqual(review.Name, result.Name);
Assert.AreEqual(review.Author.UserName, result.Author);
Assert.AreEqual(review.Text, result.Text);
Assert.AreEqual(review.Rating, result.Rating);
}
}
public void ReturnCurrectCountries_When_ParamsValid()
{
var options = Utils.GetOptions(nameof(ReturnCurrectCountries_When_ParamsValid));
var country = TestsModelsSeeder.SeedCountry();
var country2 = TestsModelsSeeder.SeedCountry2();
var country3 = TestsModelsSeeder.SeedCountry3();
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.Countries.Add(country);
arrangeContext.Countries.Add(country2);
arrangeContext.Countries.Add(country3);
arrangeContext.SaveChanges();
}
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new CountryServices(assertContext);
var result = sut.GetAllCountries().ToList();
Assert.AreEqual(3, result.Count());
Assert.AreEqual(country.Name, result[0].Name);
Assert.AreEqual(country2.Name, result[1].Name);
Assert.AreEqual(country3.Name, result[2].Name);
}
}
public void ReturnCorrectBeers_When_ParamsValid()
{
var options = Utils.GetOptions(nameof(ReturnCorrectBeers_When_ParamsValid));
var country = TestsModelsSeeder.SeedCountry();
var beerType = TestsModelsSeeder.SeedBeerType();
var brewery = TestsModelsSeeder.SeedBrewery();
var beer = TestsModelsSeeder.SeedBeer();
var beer2 = TestsModelsSeeder.SeedBeer2();
var beer3 = TestsModelsSeeder.SeedBeer3();
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.Countries.Add(country);
arrangeContext.BeerTypes.Add(beerType);
arrangeContext.Breweries.Add(brewery);
arrangeContext.Add(beer);
arrangeContext.Add(beer2);
arrangeContext.Add(beer3);
arrangeContext.SaveChanges();
}
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new BeerServices(assertContext);
var result = sut.GetAllBeers().ToList();
Assert.AreEqual(3, result.Count);
Assert.AreEqual(beer.Name, result[0].Name);
Assert.AreEqual(beer2.Name, result[1].Name);
Assert.AreEqual(beer3.Name, result[2].Name);
}
}
public void ReturnCorrectReviews_When_ParamsValid()
{
var options = Utils.GetOptions(nameof(ReturnCorrectReviews_When_ParamsValid));
var review = TestsModelsSeeder.SeedReview();
var review2 = TestsModelsSeeder.SeedReview2();
var review3 = TestsModelsSeeder.SeedReview3();
var beer = TestsModelsSeeder.SeedBeer();
var beer2 = TestsModelsSeeder.SeedBeer2();
var beer3 = TestsModelsSeeder.SeedBeer3();
var user = TestsModelsSeeder.SeedUser();
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.Reviews.Add(review);
arrangeContext.Reviews.Add(review2);
arrangeContext.Reviews.Add(review3);
arrangeContext.Users.Add(user);
arrangeContext.Beers.Add(beer);
arrangeContext.Beers.Add(beer2);
arrangeContext.Beers.Add(beer3);
arrangeContext.SaveChanges();
}
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new ReviewServices(assertContext);
var result = sut.GetAllReviews().ToList();
Assert.AreEqual(3, result.Count());
Assert.AreEqual(review.Name, result[0].Name);
Assert.AreEqual(review2.Name, result[1].Name);
Assert.AreEqual(review3.Name, result[2].Name);
}
}
public void CreateCurrectReview_When_ParamsValid()
{
var options = Utils.GetOptions(nameof(CreateCurrectReview_When_ParamsValid));
var reviewDTO = TestsModelsSeeder.SeedReviewDTO();
var user = TestsModelsSeeder.SeedUser();
var targetbeer = TestsModelsSeeder.SeedBeer();
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.Users.Add(user);
arrangeContext.Beers.Add(targetbeer);
arrangeContext.SaveChanges();
}
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new ReviewServices(assertContext);
var act = sut.CreateReview(reviewDTO);
assertContext.SaveChanges();
var result = assertContext.Reviews.ToList()[0];
Assert.AreEqual(reviewDTO.Name, result.Name);
Assert.AreEqual(reviewDTO.Rating, result.Rating);
Assert.AreEqual(reviewDTO.Text, result.Text);
Assert.AreEqual(reviewDTO.Author, reviewDTO.Author);
}
}
public void ReturnCorrectBeer_When_ParamsValid()
{
var options = Utils.GetOptions(nameof(ReturnCorrectBeer_When_ParamsValid));
var beertype = TestsModelsSeeder.SeedBeerType();
var brewery = TestsModelsSeeder.SeedBrewery();
var beerDTO = TestsModelsSeeder.SeedBeerDTO();
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.BeerTypes.Add(beertype);
arrangeContext.Breweries.Add(brewery);
arrangeContext.SaveChanges();
}
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new BeerServices(assertContext);
var act = sut.CreateBeer(beerDTO);
var result = assertContext.Beers.FirstOrDefault(beer => beer.Name == beerDTO.Name);
Assert.AreEqual(beerDTO.Id, result.Id);
Assert.AreEqual(beerDTO.Name, result.Name);
Assert.AreEqual(beerDTO.AlcoholByVolume, result.AlcoholByVolume);
Assert.AreEqual(beerDTO.Brewery, result.Brewery.Name);
}
}
public void ReturnCorrectList_WhenDataIsPresent()
{
var options = Utils.GetOptions(nameof(ReturnCorrectList_WhenDataIsPresent));
var country = TestsModelsSeeder.SeedCountry();
var brewery1 = TestsModelsSeeder.SeedBrewery();
var brewery2 = TestsModelsSeeder.SeedBrewery2();
var brewery3 = TestsModelsSeeder.SeedBrewery3();
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.Countries.Add(country);
arrangeContext.Breweries.Add(brewery1);
arrangeContext.Breweries.Add(brewery2);
arrangeContext.Breweries.Add(brewery3);
arrangeContext.SaveChanges();
}
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new BreweryServices(assertContext);
var result = sut.GetAllBreweries().ToList();
Assert.AreEqual(3, result.Count);
Assert.AreEqual(brewery1.Name, result[0].Name);
Assert.AreEqual(brewery2.Name, result[1].Name);
Assert.AreEqual(brewery3.Name, result[2].Name);
}
}
public void UpdateCorrectBeer_When_ParamsAreValid()
{
var options = Utils.GetOptions(nameof(UpdateCorrectBeer_When_ParamsAreValid));
var beer = TestsModelsSeeder.SeedBeer();
var beerType = TestsModelsSeeder.SeedBeerType();
var brewery = TestsModelsSeeder.SeedBrewery();
var country = TestsModelsSeeder.SeedCountry();
var beer2 = TestsModelsSeeder.SeedBeer2();
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.Countries.Add(country);
arrangeContext.Breweries.Add(brewery);
arrangeContext.BeerTypes.Add(beerType);
arrangeContext.Beers.Add(beer);
arrangeContext.Beers.Add(beer2);
arrangeContext.SaveChanges();
}
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new BeerServices(assertContext);
var act = sut.UpdateBeer(1, "NewBeerName", beer2.Type.Name, brewery.Name, 6);
var result = sut.GetBeer(1);
Assert.AreEqual("NewBeerName", result.Name);
Assert.AreEqual(beer2.Type.Name, result.BeerType);
Assert.AreEqual(brewery.Name, result.Brewery);
Assert.AreEqual(6, result.AlcoholByVolume);
}
}
public void ReturnCorrectBeerType_WhenParamsAreValid()
{
var options = Utils.GetOptions(nameof(ReturnCorrectBeerType_WhenParamsAreValid));
var beerTypeDTO = TestsModelsSeeder.SeedBeerTypeDTO();
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new BeerTypeServices(assertContext);
var act = sut.CreateBeerType(beerTypeDTO);
var result = assertContext.BeerTypes.FirstOrDefault(beerType => beerType.Name == beerTypeDTO.Name);
Assert.AreEqual(beerTypeDTO.Id, result.Id);
Assert.AreEqual(beerTypeDTO.Name, result.Name);
}
}
public void ThrowArgumentException_When_BeerAlreadyExists()
{
var options = Utils.GetOptions(nameof(ThrowArgumentException_When_BeerAlreadyExists));
var beerDTO = TestsModelsSeeder.SeedBeerDTO();
var beer = TestsModelsSeeder.SeedBeer();
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.Beers.Add(beer);
arrangeContext.SaveChanges();
}
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new BeerServices(assertContext);
}
}
public void Throw_When_BeerTypeAlreadyExists()
{
var options = Utils.GetOptions(nameof(Throw_When_BeerTypeAlreadyExists));
var beerTypeDTO = TestsModelsSeeder.SeedBeerTypeDTO();
var beerType = TestsModelsSeeder.SeedBeerType();
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.BeerTypes.Add(beerType);
arrangeContext.SaveChanges();
}
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new BeerTypeServices(assertContext);
Assert.ThrowsException <ArgumentException>(() => sut.CreateBeerType(beerTypeDTO));
}
}
public void ThrowArgumentException_When_TargetBeerNotValid()
{
var options = Utils.GetOptions(nameof(ThrowArgumentException_When_TargetBeerNotValid));
var user = TestsModelsSeeder.SeedUser();
var reviewDTO = TestsModelsSeeder.SeedReviewDTO();
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.Users.Add(user);
arrangeContext.SaveChanges();
}
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new ReviewServices(assertContext);
Assert.ThrowsException <ArgumentNullException>(() => sut.CreateReview(reviewDTO));
}
}
public void ReturnFalse_WhenUserIdIsIncorrect()
{
var options = Utils.GetOptions(nameof(ReturnFalse_WhenUserIdIsIncorrect));
var user = TestsModelsSeeder.SeedUser();
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.Users.Add(user);
arrangeContext.SaveChanges();
}
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new UserServices(assertContext);
var result = sut.DeleteUser(user.Id + 1);
Assert.IsFalse(result);
}
}
public void ChangeCorrect_IsDelete_ToTrue()
{
var options = Utils.GetOptions(nameof(ChangeCorrect_IsDelete_ToTrue));
var beer = TestsModelsSeeder.SeedBeer();
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.Beers.Add(beer);
arrangeContext.SaveChanges();
}
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new BeerServices(assertContext);
var act = sut.DeleteBeer(1);
Assert.IsTrue(assertContext.Beers.FirstOrDefault(beer => beer.Id == 1).IsDeleted);
};
}
public void ReturnFalse_WhenIdIsIncorrect()
{
var options = Utils.GetOptions(nameof(ReturnFalse_WhenIdIsIncorrect));
var beerType = TestsModelsSeeder.SeedBeerType();
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.BeerTypes.Add(beerType);
arrangeContext.SaveChanges();
}
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new BeerTypeServices(assertContext);
var result = sut.DeleteBeerType(beerType.Id + 1);
Assert.IsFalse(result);
}
}
public void ReturnTrue_WhenIdIsCorrect()
{
var options = Utils.GetOptions(nameof(ReturnTrue_WhenIdIsCorrect));
var brewery = TestsModelsSeeder.SeedBrewery();
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.Breweries.Add(brewery);
arrangeContext.SaveChanges();
}
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new BreweryServices(assertContext);
var result = sut.DeleteBrewery(brewery.Id);
Assert.IsTrue(result);
}
}
public void Throw_WhenBeersDrankBeerIdIsInvalid()
{
var options = Utils.GetOptions(nameof(Throw_WhenBeersDrankBeerIdIsInvalid));
var user = TestsModelsSeeder.SeedUser();
var beer = TestsModelsSeeder.SeedBeer();
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.Users.Add(user);
arrangeContext.Beers.Add(beer);
arrangeContext.SaveChanges();
}
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new UserServices(assertContext);
Assert.ThrowsException <ArgumentNullException>(() => sut.AddToWishlist(1, 2));
}
}
public void ReturnCurrectCountry_When_ParamsValid()
{
var options = Utils.GetOptions(nameof(ReturnCurrectCountry_When_ParamsValid));
var country = TestsModelsSeeder.SeedCountry();
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.Countries.Add(country);
arrangeContext.SaveChanges();
}
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new CountryServices(assertContext);
var result = sut.GetCountry(1);
Assert.AreEqual(country.Name, result.Name);
Assert.AreEqual(country.Code, result.CountryCode);
}
}
public void ReturnFalse_When_ReviewAlreadyDel()
{
var options = Utils.GetOptions(nameof(ReturnFalse_When_ReviewAlreadyDel));
var review = TestsModelsSeeder.SeedReview();
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.Reviews.Add(review);
arrangeContext.SaveChanges();
}
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new ReviewServices(assertContext);
var act = sut.DeleteReview(1);
var result = sut.DeleteReview(1);
Assert.IsFalse(result);
}
}
public void Throw_WhenBreweryIdIsInvalid()
{
var options = Utils.GetOptions(nameof(Throw_WhenBreweryIdIsInvalid));
var brewery1 = TestsModelsSeeder.SeedBrewery();
var brewery2 = TestsModelsSeeder.SeedBrewery2();
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.Breweries.Add(brewery1);
arrangeContext.Breweries.Add(brewery2);
arrangeContext.SaveChanges();
}
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new BreweryServices(assertContext);
Assert.ThrowsException <ArgumentNullException>(() => sut.UpdateBrewery(5, "NewBrewery", "Bulgaria"));
}
}
public void Throw_WhenBreweryAlreadyExists()
{
var options = Utils.GetOptions(nameof(Throw_WhenBreweryAlreadyExists));
var breweryDTO = TestsModelsSeeder.SeedBreweryDTO();
var brewery = TestsModelsSeeder.SeedBrewery();
var country = TestsModelsSeeder.SeedCountry();
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.Countries.Add(country);
arrangeContext.Breweries.Add(brewery);
arrangeContext.SaveChanges();
}
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new BreweryServices(assertContext);
Assert.ThrowsException <ArgumentException>(() => sut.CreateBrewery(breweryDTO));
}
}
public void DeleteUser_WhenIdIsCorrect()
{
var options = Utils.GetOptions(nameof(DeleteUser_WhenIdIsCorrect));
var user = TestsModelsSeeder.SeedUser();
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.Users.Add(user);
arrangeContext.SaveChanges();
}
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new UserServices(assertContext);
var act = sut.DeleteUser(user.Id);
var result = assertContext.Users.FirstOrDefault(u => u.UserName == user.UserName);
Assert.IsTrue(result.IsDeleted);
}
}
public void Throw_WhenBeerTypeIdIsInvalid()
{
var options = Utils.GetOptions(nameof(Throw_WhenBeerTypeIdIsInvalid));
var beerType1 = TestsModelsSeeder.SeedBeerType();
var beerType2 = TestsModelsSeeder.SeedBeerType2();
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.BeerTypes.Add(beerType1);
arrangeContext.BeerTypes.Add(beerType2);
arrangeContext.SaveChanges();
}
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new BeerTypeServices(assertContext);
Assert.ThrowsException <ArgumentNullException>(() => sut.UpdateBeerType(5, "newBeerType"));
}
}
public void DeleteBeerType_WhenIdIsCorrect()
{
var options = Utils.GetOptions(nameof(DeleteBeerType_WhenIdIsCorrect));
var beerType = TestsModelsSeeder.SeedBeerType();
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.BeerTypes.Add(beerType);
arrangeContext.SaveChanges();
}
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new BeerTypeServices(assertContext);
var act = sut.DeleteBeerType(beerType.Id);
var result = assertContext.BeerTypes.FirstOrDefault(bt => bt.Name == beerType.Name).IsDeleted;
Assert.IsTrue(result);
}
}
public void Throw_WhenEmailAlreadyTaken()
{
var options = Utils.GetOptions(nameof(Throw_WhenEmailAlreadyTaken));
var user1 = TestsModelsSeeder.SeedUser();
var user2 = TestsModelsSeeder.SeedUser2();
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.Users.Add(user1);
arrangeContext.Users.Add(user2);
arrangeContext.SaveChanges();
}
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new UserServices(assertContext);
Assert.ThrowsException <ArgumentException>(() => sut.UpdateUser(2, "User2Name", user1.Email, false, null));
}
}
public void Throw_WhenUserIdIsInvalid()
{
var options = Utils.GetOptions(nameof(Throw_WhenUserIdIsInvalid));
var user1 = TestsModelsSeeder.SeedUser();
var user2 = TestsModelsSeeder.SeedUser2();
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.Users.Add(user1);
arrangeContext.Users.Add(user2);
arrangeContext.SaveChanges();
}
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new UserServices(assertContext);
Assert.ThrowsException <ArgumentNullException>(() => sut.UpdateUser(5, "User2Name", "*****@*****.**", false, null));
}
}
public void Throw_WhenUserAlreadyExists()
{
var options = Utils.GetOptions(nameof(Throw_WhenUserAlreadyExists));
var userRole = TestsModelsSeeder.SeedUserRole();
var userDTO = TestsModelsSeeder.SeedUserDTO();
var user = TestsModelsSeeder.SeedUser();
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.Roles.Add(userRole);
arrangeContext.Users.Add(user);
arrangeContext.SaveChanges();
}
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new UserServices(assertContext);
Assert.ThrowsException <ArgumentException>(() => sut.CreateUser(userDTO));
}
}
