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 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 async Task <IActionResult> Create([Bind("Id,Name,CreatedOn,ModifiedOn,IsDeleted,DeletedOn")] BeerType beerType)
        {
            if (ModelState.IsValid)
            {
                _context.Add(beerType);
                await _context.SaveChangesAsync();

                return(RedirectToAction(nameof(Index)));
            }
            return(View(beerType));
        }
Exemple #4
0
        public async Task <IActionResult> Create([Bind("FirstName,LastName,DateOfBirth,CreatedOn,isBanned,banDescription,Id,UserName,NormalizedUserName,Email,NormalizedEmail,EmailConfirmed,PasswordHash,SecurityStamp,ConcurrencyStamp,PhoneNumber,PhoneNumberConfirmed,TwoFactorEnabled,LockoutEnd,LockoutEnabled,AccessFailedCount")] User user)
        {
            if (ModelState.IsValid)
            {
                _context.Add(user);
                await _context.SaveChangesAsync();

                return(RedirectToAction(nameof(Index)));
            }
            return(View(user));
        }
Exemple #5
0
        public async Task <IActionResult> Create([Bind("Id,Name,CountryId,IsDeleted,DeletedOn,CreatedOn,ModifiedOn")] Brewery brewery)
        {
            if (ModelState.IsValid)
            {
                _context.Add(brewery);
                await _context.SaveChangesAsync();

                return(RedirectToAction(nameof(Index)));
            }
            ViewData["CountryId"] = new SelectList(_context.Countries, "Id", "Name", brewery.CountryId);
            return(View(brewery));
        }
        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);
            }
        }
        public async Task <IActionResult> Create([Bind("Id,Rating,Name,Text,TargetBeerId,AuthorId,ModifiedOn,IsDeleted,DeletedOn")] Review review)
        {
            if (ModelState.IsValid)
            {
                _context.Add(review);
                await _context.SaveChangesAsync();

                return(RedirectToAction(nameof(Index)));
            }
            ViewData["AuthorId"]     = new SelectList(_context.Users, "Id", "Email", review.AuthorId);
            ViewData["TargetBeerId"] = new SelectList(_context.Beers, "Id", "Name", review.TargetBeerId);
            return(View(review));
        }
        public async Task <IActionResult> Create([Bind("Id,Name,TypeId,BreweryId,CreatedOn,DeletedOn,ModifiedOn,IsDeleted,AlcoholByVolume")] Beer beer)
        {
            if (ModelState.IsValid)
            {
                _context.Add(beer);
                await _context.SaveChangesAsync();

                return(RedirectToAction(nameof(Index)));
            }
            ViewData["BreweryId"] = new SelectList(_context.Breweries, "Id", "Name", beer.BreweryId);
            ViewData["TypeId"]    = new SelectList(_context.BeerTypes, "Id", "Name", beer.TypeId);
            return(View(beer));
        }
Exemple #9
0
        public async Task <IActionResult> Create([Bind("UserId,BeerId")] BeerDrank beerDrank)
        {
            if (ModelState.IsValid)
            {
                var beersDrankExists = _context.BeersDrank.FirstOrDefault(wb => wb.UserId == beerDrank.UserId && wb.BeerId == beerDrank.BeerId);
                if (beersDrankExists == null)
                {
                    _context.Add(beerDrank);
                }
                await _context.SaveChangesAsync();

                return(RedirectToAction(nameof(Index)));
            }
            ViewData["BeerId"] = new SelectList(_context.Beers, "Id", "Name", beerDrank.BeerId);
            ViewData["UserId"] = new SelectList(_context.Users, "Id", "Email", beerDrank.UserId);
            return(View(beerDrank));
        }
Exemple #10
0
        public async Task <IActionResult> Create([Bind("UserId,BeerId")] WishlistBeer wishlistBeer)
        {
            if (ModelState.IsValid)
            {
                var wishlistBeerExists = _context.WishlistBeers.FirstOrDefault(wb => wb.UserId == wishlistBeer.UserId && wb.BeerId == wishlistBeer.BeerId);
                if (wishlistBeerExists == null)
                {
                    _context.Add(wishlistBeer);
                }
                await _context.SaveChangesAsync();

                return(RedirectToAction(nameof(Index)));
            }
            ViewData["BeerId"] = new SelectList(_context.Beers, "Id", "Name", wishlistBeer.BeerId);
            ViewData["UserId"] = new SelectList(_context.Users, "Id", "Email", wishlistBeer.UserId);
            return(View(wishlistBeer));
        }
        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);
            }
        }