public IBeerDTO CreateBeer(IBeerDTO beerDTO)
{
var beerExists = _context.Beers
.FirstOrDefault(b => b.Name == beerDTO.Name && b.Brewery.Name == beerDTO.Brewery);
if (beerExists != null)
{
throw new ArgumentException("Beer with this name and brewery already exists.");
}
;
var beer = new Beer
{
Name = beerDTO.Name,
Type = _context.BeerTypes
.FirstOrDefault(t => t.Name == beerDTO.BeerType)
?? throw new ArgumentNullException("Beer Type not found."),
Brewery = _context.Breweries
.FirstOrDefault(b => b.Name == beerDTO.Brewery)
?? throw new ArgumentNullException("Brewery not found."),
AlcoholByVolume = beerDTO.AlcoholByVolume
};
_context.Beers.Add(beer);
_context.SaveChanges();
return(beerDTO);
}
public IUserDTO CreateUser(IUserDTO userDTO)
{
var userExists = _context.Users
.FirstOrDefault(u => u.UserName == userDTO.UserName);
if (userExists != null)
{
throw new ArgumentException("A user with that name already exists.");
}
var emailExists = _context.Users
.FirstOrDefault(u => u.Email == userDTO.Email);
if (emailExists != null)
{
throw new ArgumentException("A user with that email is already registered.");
}
var user = new User
{
UserName = userDTO.UserName,
Email = userDTO.Email,
IsBanned = userDTO.IsBanned,
BanReason = userDTO.BanReason
};
_context.Users.Add(user);
_context.SaveChanges();
return(userDTO);
}
public CountryDTO CreateCountry(CountryDTO countryDTO)
{
var country = new Country
{
Id = countryDTO.Id,
Name = countryDTO.Name,
};
_beerOverflowContext.Countries.Add(country);
_beerOverflowContext.SaveChanges();
return(countryDTO);
}
public BreweryDTO CreateBrewery(BreweryDTO breweryDTO)
{
var brewery = new Brewery
{
Id = breweryDTO.Id,
Name = breweryDTO.Name,
Description = breweryDTO.Description,
CountryId = breweryDTO.CountryId,
};
_beerOverflowContext.Breweries.Add(brewery);
_beerOverflowContext.SaveChanges();
return(breweryDTO);
}
public BeerDTO CreateBeer(BeerDTO beerDTO)
{
try
{
var beer = new Beer(beerDTO.BeerName, beerDTO.BeerTypeId, beerDTO.BreweryId,
beerDTO.AlcByVol, beerDTO.Description);
_beerOverflowContext.Beers.Add(beer);
_beerOverflowContext.SaveChanges();
return(beerDTO);
}
catch (Exception)
{
throw;
}
}
public void Return_Correct_Edited_User()
{
var options = Utils.GetOptions(nameof(Return_Correct_Edited_User));
var user = new User
{
Id = 1,
UserName = "******",
FirstName = "Boyan",
LastName = "Vuchev",
Email = "*****@*****.**",
CreatedOn = DateTime.UtcNow
};
var mockArtistMapper = new Mock <IDateTimeProvider>();
var username = "******";
var newEmail = "*****@*****.**";
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.Users.Add(user);
arrangeContext.SaveChanges();
}
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new UserService(assertContext, mockArtistMapper.Object);
var result = sut.UpdateUser(user.Id, username, user.FirstName, user.LastName, newEmail);
Assert.AreEqual(user.Id, result.Id);
Assert.AreEqual(username, result.Username);
Assert.AreEqual(newEmail, result.Email);
}
}
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 Return_Correct_Edited_Brewery()
{
var options = Utils.GetOptions(nameof(Return_Correct_Edited_Brewery));
var brewery = new Brewery
{
Id = 1,
Name = "Diamond Knot Brewery",
Description = "America",
CountryId = 1
};
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.Breweries.Add(brewery);
arrangeContext.SaveChanges();
}
var newName = "DKB";
var newDescr = "USA";
var newCountryId = 2;
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new BreweryService(assertContext);
var result = sut.UpdateBrewery(brewery.Id, newName, newDescr, newCountryId);
Assert.AreEqual(brewery.Id, result.Id);
Assert.AreEqual(newName, result.Name);
Assert.AreEqual(newDescr, result.Description);
Assert.AreEqual(newCountryId, result.CountryId);
}
}
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 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 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 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 ReturnTrue_When_TypeIsDeleted()
{
var options = Utils.GetOptions(nameof(ReturnTrue_When_TypeIsDeleted));
var brewery = new Brewery
{
Id = 1,
Name = "Diamond Knot Brewery",
Description = "America",
CountryId = 1
};
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.Breweries.Add(brewery);
arrangeContext.SaveChanges();
}
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new BreweryService(assertContext);
var result = sut.DeleteBrewery(1);
Assert.IsTrue(result);
}
}
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 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 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 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 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 ReturnTrue_When_UserIsDeleted()
{
var options = Utils.GetOptions(nameof(ReturnTrue_When_UserIsDeleted));
var user = new User
{
Id = 1,
UserName = "******",
FirstName = "Boyan",
LastName = "Vuchev",
Email = "*****@*****.**",
CreatedOn = DateTime.UtcNow
};
var mockArtistMapper = new Mock <IDateTimeProvider>();
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.Users.Add(user);
arrangeContext.SaveChanges();
}
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new UserService(assertContext, mockArtistMapper.Object);
var result = sut.DeleteUser(1);
Assert.IsTrue(result);
}
}
public void Return_Correct_Edited_Type()
{
var options = Utils.GetOptions(nameof(Return_Correct_Edited_Type));
var beerType = new BeerType
{
Id = 1,
Description = "Type of beer conditioned at low temperatures.",
Type = "Lager",
};
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.BeerTypes.Add(beerType);
arrangeContext.SaveChanges();
}
var newType = "Lageerr";
var newDescr = "Updated";
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new BeerTypesService(assertContext);
var result = sut.UpdateBeerType(beerType.Id, newType, newDescr);
Assert.AreEqual(beerType.Id, result.Id);
Assert.AreEqual(newType, result.Type);
Assert.AreEqual(newDescr, result.Description);
}
}
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 UserBeersDTO AddBeerToDrankList(string userName, string beerName)
{
var user = _beerOverflowContext.Users.FirstOrDefault(u => u.UserName == userName);
if (user == null)
{
throw new ArgumentNullException("User is null!");
}
var beer = _beerOverflowContext.Beers.FirstOrDefault(b => b.BeerName == beerName);
if (beer == null)
{
throw new ArgumentNullException("Beer is null!");
}
var userBeer = _beerOverflowContext.UserBeers
.Where(ub => ub.UserId == user.Id)
.FirstOrDefault(ub => ub.BeerId == beer.Id);
if (userBeer == null)
{
var newUserBeer = new UserBeers
{
UserId = user.Id,
BeerId = beer.Id,
DrankOn = DateTime.UtcNow
};
_beerOverflowContext.UserBeers.Add(newUserBeer);
_beerOverflowContext.SaveChanges();
}
else
{
if (userBeer.DrankOn == null)
{
userBeer.DrankOn = DateTime.UtcNow;
_beerOverflowContext.SaveChanges();
}
else
{
throw new ArgumentException("Already drank this beer!");
}
}
var userBeerDTO = new UserBeersDTO(user.UserName, user.Id,
beer.BeerName, beer.Id, userBeer.DrankOn);
return(userBeerDTO);
}
public IBeerTypeDTO CreateBeerType(IBeerTypeDTO beerTypeDTO)
{
var beerType = new BeerType
{
Name = beerTypeDTO.Name
};
var beerTypeExists = _context.BeerTypes
.FirstOrDefault(b => b.Name == beerTypeDTO.Name);
if (beerTypeExists != null)
{
throw new ArgumentException($"BeerType {beerTypeExists.Name} already exists");
}
_context.BeerTypes.Add(beerType);
_context.SaveChanges();
return(beerTypeDTO);
}
public UserDTO CreateUser(UserDTO userDTO)
{
var user = new User
{
Id = userDTO.Id,
UserName = userDTO.Username,
FirstName = userDTO.FirstName,
LastName = userDTO.LastName,
Email = userDTO.Email,
CreatedOn = this.dateTimeProvider.GetDateTime()
};
_beerOverflowContext.Users.Add(user);
_beerOverflowContext.SaveChanges();
return(userDTO);
}
public BeerTypeDTO CreateBeerType(BeerTypeDTO beerTypeDTO)
{
try
{
var beerType = new BeerType
{
Type = beerTypeDTO.Type,
Description = beerTypeDTO.Description,
};
_beerOverflowContext.BeerTypes.Add(beerType);
_beerOverflowContext.SaveChanges();
return(beerTypeDTO);
}
catch (Exception)
{
throw;
}
}
public IBreweryDTO CreateBrewery(IBreweryDTO breweryDTO)
{
var brewery = new Brewery
{
Name = breweryDTO.Name,
Country = _context.Countries
.FirstOrDefault(c => c.Name == breweryDTO.Country) ?? throw new ArgumentNullException("Country not found.")
};
var breweryExists = _context.Breweries
.FirstOrDefault(b => b.Name == brewery.Name && b.Country == brewery.Country);
if (breweryExists != null)
{
throw new ArgumentException($"Brewery {brewery.Name} already exists in {brewery.Country.Name}");
}
_context.Breweries.Add(brewery);
_context.SaveChanges();
return(breweryDTO);
}
public void ReturnCorrectWishlist_WhenParamsAreValid()
{
var options = Utils.GetOptions(nameof(ReturnCorrectWishlist_WhenParamsAreValid));
var userRole = TestsModelsSeeder.SeedUserRole();
var user1 = TestsModelsSeeder.SeedUser();
var beer1 = TestsModelsSeeder.SeedBeer();
var beer2 = TestsModelsSeeder.SeedBeer2();
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.Roles.Add(userRole);
arrangeContext.Users.Add(user1);
arrangeContext.Beers.Add(beer1);
arrangeContext.Beers.Add(beer2);
arrangeContext.SaveChanges();
arrangeContext.Users.FirstOrDefault().Wishlist = new HashSet <WishlistBeer>
{
new WishlistBeer
{
UserId = 1,
BeerId = 1,
},
new WishlistBeer
{
UserId = 1,
BeerId = 2,
}
};
arrangeContext.SaveChanges();
}
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new UserServices(assertContext);
var result = sut.GetWishlist(1).ToList();
Assert.AreEqual(2, result.Count);
Assert.AreEqual(2, result[0].Id);
Assert.AreEqual(1, result[1].Id);
}
}
public IActionResult AddToWishlist(int?Id)
{
if (Id == null)
{
return(NotFound());
}
var user = _context.Users.FirstOrDefault(u => u.UserName == HttpContext.User.Identity.Name);
var beer = _context.Beers.FirstOrDefault(b => b.Id == Id);
var wishlistExists = _context.WishlistBeers.FirstOrDefault(l => l.UserId == user.Id && l.BeerId == Id);
if (wishlistExists == null)
{
var wishlist = new WishlistBeer
{
UserId = user.Id,
User = user,
BeerId = (int)Id,
Beer = beer
};
_context.WishlistBeers.Add(wishlist);
_context.SaveChanges();
}
return(Redirect("~/WishlistBeers"));
}
public IReviewDTO CreateReview(IReviewDTO reviewDTO)
{
if (_context.Reviews
.FirstOrDefault(r => r.TargetBeer.Name == reviewDTO.TargetBeer && r.Author.UserName == reviewDTO.Author) != null)
{
throw new ArgumentException("Review with on this beer from this user already exists.");
}
var review = new Review
{
Rating = reviewDTO.Rating,
Name = reviewDTO.Name,
Text = reviewDTO.Text,
Author = _context.Users
.FirstOrDefault(u => u.UserName == reviewDTO.Author)
?? throw new ArgumentNullException("No author with this name."),
TargetBeer = _context.Beers
.FirstOrDefault(b => b.Name == reviewDTO.TargetBeer)
?? throw new ArgumentNullException("No beer with this name."),
};
_context.Reviews.Add(review);
_context.SaveChanges();
return(reviewDTO);
}
public void Return_Correct_Breweries()
{
var options = Utils.GetOptions(nameof(Return_Correct_Breweries));
var country = new Country
{
Id = 1,
Name = "America"
};
var brewery = new Brewery
{
Id = 1,
Name = "Diamond Knot Brewery",
Description = "America",
CountryId = 1,
Country = country
};
var brewery2 = new Brewery
{
Id = 2,
Name = "Anheuser-Busch",
Description = "American brewery",
CountryId = 1,
Country = country
};
using (var arrangeContext = new BeerOverflowContext(options))
{
arrangeContext.Breweries.Add(brewery);
arrangeContext.Breweries.Add(brewery2);
arrangeContext.SaveChanges();
}
using (var assertContext = new BeerOverflowContext(options))
{
var sut = new BreweryService(assertContext);
var result = sut.GetAllBreweries().First();
Assert.AreEqual(brewery.Id, result.Id);
Assert.AreEqual(brewery.Name, result.Name);
Assert.AreEqual(brewery.Description, result.Description);
Assert.AreEqual(brewery.CountryId, result.CountryId);
Assert.AreEqual(brewery.Country.Name, result.Country);
}
}
