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);
            }
        }
예제 #2
0
        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 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 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 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);
            }
        }
예제 #7
0
        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);
            }
        }
예제 #8
0
        public void ThrowArgumentException_When_UserNotValid()
        {
            var options    = Utils.GetOptions(nameof(ThrowArgumentException_When_UserNotValid));
            var reviewDTO  = TestsModelsSeeder.SeedReviewDTO();
            var targetbeer = TestsModelsSeeder.SeedBeer();

            using (var arrangeContext = new BeerOverflowContext(options))
            {
                arrangeContext.Beers.Add(targetbeer);
                arrangeContext.SaveChanges();
            }
            using (var assertContext = new BeerOverflowContext(options))
            {
                var sut = new ReviewServices(assertContext);
                Assert.ThrowsException <ArgumentNullException>(() => sut.CreateReview(reviewDTO));
            }
        }
        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));
            }
        }
예제 #10
0
        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 ReturnTrue_WhenBeerAddedCorrectlyToBeersDrank()
        {
            var options = Utils.GetOptions(nameof(ReturnTrue_WhenBeerAddedCorrectlyToBeersDrank));
            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);
                var result = sut.AddToWishlist(1, 1);
                Assert.IsTrue(result);
            }
        }
예제 #12
0
        public void ReturnFalse_When_BeerToDelete_AlreadyDeleted()
        {
            var options = Utils.GetOptions(nameof(ReturnFalse_When_BeerToDelete_AlreadyDeleted));

            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);
                var result = sut.DeleteBeer(1);
                Assert.IsFalse(result);
            };
        }
        public void ReturnTrue_When_ParamsValid()
        {
            var options = Utils.GetOptions(nameof(ReturnTrue_When_ParamsValid));

            var review = TestsModelsSeeder.SeedReview();
            var beer   = TestsModelsSeeder.SeedBeer();

            using (var arrangeContext = new BeerOverflowContext(options))
            {
                arrangeContext.Add(review);
                arrangeContext.Add(beer);
                arrangeContext.SaveChanges();
            }
            using (var assertContext = new BeerOverflowContext(options))
            {
                var sut    = new ReviewServices(assertContext);
                var result = sut.DeleteReview(1);
                Assert.IsTrue(result);
                Assert.IsTrue(assertContext.Reviews.FirstOrDefault().IsDeleted);
            }
        }
예제 #14
0
        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 void AddBeerCorrectly_WhenParamsAreValid()
        {
            var options = Utils.GetOptions(nameof(AddBeerCorrectly_WhenParamsAreValid));
            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);
                var act    = sut.AddToBeersDrank(1, 1);
                var result = assertContext.Users.FirstOrDefault(u => u.UserName == user.UserName).BeersDrank.ToList();
                Assert.AreEqual(1, result.Count);
                Assert.AreEqual(beer.Id, result[0].BeerId);
            }
        }
        public void UpdateCorrectReview_When_ParamsValid()
        {
            var options = Utils.GetOptions(nameof(UpdateCorrectReview_When_ParamsValid));
            var review  = TestsModelsSeeder.SeedReview();
            var beer    = TestsModelsSeeder.SeedBeer();
            var user    = TestsModelsSeeder.SeedUser();

            using (var arrangeContext = new BeerOverflowContext(options))
            {
                arrangeContext.Users.Add(user);
                arrangeContext.Add(review);
                arrangeContext.Beers.Add(beer);
                arrangeContext.SaveChanges();
            }
            using (var assertContext = new BeerOverflowContext(options))
            {
                var sut    = new ReviewServices(assertContext);
                var act    = sut.UpdateReviews(1, "NewReviewName", "Changed my mind, I don't like it.", 2);
                var result = assertContext.Reviews.ToList()[0];
                Assert.AreEqual("NewReviewName", result.Name);
                Assert.AreEqual("Changed my mind, I don't like it.", result.Text);
                Assert.AreEqual(2, result.Rating);
            }
        }