public async Task Edit_ReturnsNotFound_WhenNotFound()
        {
            // Arrange
            User  user     = _context.Users.FirstOrDefault();
            Event activity = new Event
            {
                UserId           = user.Id,
                EventId          = 666,
                EventDateTime    = DateTime.Now,
                EventDescription = "whatever",
                EventName        = "whatever2",
            };

            _context.Add(activity);

            Event activity2 = new Event
            {
                UserId           = user.Id,
                EventId          = 2,
                EventDateTime    = DateTime.Now,
                EventDescription = "whatever",
                EventName        = "whatever2",
            };

            await _context.SaveChangesAsync();

            // Act
            var result = await ControllerSUT.Edit(activity2.EventId, activity2);

            // Assert
            Assert.IsAssignableFrom <NotFoundResult>(result);
        }
        public async Task Edit_ReturnsNotFound_WhenProfileIdDoesNotMatchPostBody(int id)
        {
            // Arrange

            // Act
            var result = await ControllerSUT.Edit(666);

            // Assert
            Assert.IsAssignableFrom <NotFoundResult>(result);
        }
Exemple #3
0
        public async Task Edit_ReturnsNotFound_WhenImageIdDoesNotMatchPostBody(int id)
        {
            // Arrange

            // Act
            var result = await ControllerSUT.Edit(331, new Image { ImageId = 55, ImageURL = "https://cdn.steamgriddb.com/thumb/df3cdfd672004f1a0058d81c56e7270a.png" });

            // Assert
            Assert.IsAssignableFrom <NotFoundResult>(result);
        }
Exemple #4
0
        public async Task Edit_ReturnsNotFound_WhenImageIdIsNotFound(int?id)
        {
            // Arrange

            // Act
            var result = await ControllerSUT.Edit(id);

            // Assert
            Assert.IsAssignableFrom <NotFoundResult>(result);
        }
Exemple #5
0
        public async Task Edit_ReturnsNotFound_WhenIdDoesNotMatchPostBody(int gameId)
        {
            // Arrange

            // Act
            var result = await ControllerSUT.Edit(2, new Review { ReviewId = review1.ReviewId, Game = game1, GameId = gameId, ReviewContent = "fun", Rating = 2 });

            // Assert
            Assert.IsAssignableFrom <NotFoundResult>(result);
        }
        public async Task Edit_ReturnsNotFound_WhenAddressIdIsNotFound(int?addressId)
        {
            // Arrange
            GetUserAsyncReturns = identityUser;
            // Act
            var result = await ControllerSUT.Edit(addressId);

            // Assert
            Assert.IsAssignableFrom <NotFoundResult>(result);
        }
        public async Task Edit_ReturnsNotFound_WhenEventIdIsNull()
        {
            // Arrange

            // Act
            var result = await ControllerSUT.Edit(null);

            // Assert
            Assert.IsAssignableFrom <NotFoundResult>(result);
        }
Exemple #8
0
        public async Task Edit_ReturnsNotFound_WhenGameIdDoesNotMatchPostBody(int gameId)
        {
            // Arrange

            // Act
            var result = await ControllerSUT.Edit(2, new Game { GameId = gameId, Developer = "Blizzard", Name = "StarCraft", GameTypeId = 2 });

            // Assert
            Assert.IsAssignableFrom <NotFoundResult>(result);
        }
        public async Task Edit_ReturnsViewResult_WhenIdIsFound()
        {
            // Arrange

            // Act
            var result = await ControllerSUT.Edit(166);

            // Assert
            var viewResult = Assert.IsAssignableFrom <ViewResult>(result);

            Assert.IsAssignableFrom <Profile>(viewResult.ViewData.Model);
        }
Exemple #10
0
        public async Task Edit_RedirectToAction_WhenGameIdIsFound()
        {
            // Arrange
            GetUserAsyncReturns = _context.Users.FirstOrDefault();

            // Act
            var result = await ControllerSUT.Edit(WishlistVisibility.OnlyMe);

            // Assert
            var viewResult = Assert.IsAssignableFrom<RedirectToActionResult>(result);
            Assert.Equal(nameof(GameController.Index), viewResult.ActionName);
        }
        public async Task Edit_ReturnsViewResult_WhenIdFound()
        {
            // Arrange
            GetUserAsyncReturns = identityUser;
            //Act
            var result = await ControllerSUT.Edit(1);

            //Assert
            var viewResult = Assert.IsAssignableFrom <ViewResult>(result);

            Assert.IsAssignableFrom <Address>(viewResult.ViewData.Model);

            Assert.NotNull(viewResult);
        }
Exemple #12
0
        public async Task Edit_ReturnsViewResult_WhenGameIdIsFound()
        {
            // Arrange

            // Act
            var result = await ControllerSUT.Edit(1);

            // Assert
            var viewResult = Assert.IsAssignableFrom <ViewResult>(result);
            var selectList = Assert.IsAssignableFrom <SelectList>(viewResult.ViewData["GameTypeId"]);

            Assert.IsAssignableFrom <Game>(viewResult.ViewData.Model);

            Assert.NotEmpty(selectList);
        }
Exemple #13
0
        public async Task Edit_ReturnsViewResult_WhenGameIsUpdated()
        {
            // Arrange

            // Act
            var result = await ControllerSUT.Edit(1, new Game { GameId = 1, Developer = "Blizzard", Name = "StarCraft", GameTypeId = 2 });

            // Assert
            var redirectResult = Assert.IsAssignableFrom <ViewResult>(result);
            var game           = Assert.IsAssignableFrom <Game>(_context.Games.FirstOrDefault(g => g.GameId == 1));

            Assert.Equal(1, game.GameId);
            Assert.Equal("Blizzard", game.Developer);
            Assert.Equal("StarCraft", game.Name);
            Assert.Equal(2, game.GameTypeId);
        }
        public async Task Edit_ReturnsViewResult_WhenSuccessful()
        {
            // Arrange
            User  user     = _context.Users.FirstOrDefault();
            Event activity = new Event
            {
                UserId           = user.Id,
                EventId          = 2,
                EventDateTime    = DateTime.Now,
                EventDescription = "whatever",
                EventName        = "whatever2",
            };

            _context.Add(activity);
            await _context.SaveChangesAsync();

            // Act
            var result = await ControllerSUT.Edit(activity.EventId, activity);

            // Assert
            Assert.IsAssignableFrom <RedirectToActionResult>(result);
        }
        public async Task Edit_ReturnsViewResult_WhenModelStateIsInvalid()
        {
            // Arrange
            User  user     = _context.Users.FirstOrDefault();
            Event activity = new Event
            {
                EventId       = 2,
                EventDateTime = DateTime.Now,
            };

            _context.Add(activity);
            await _context.SaveChangesAsync();

            SimulateModelStateValidation(activity);

            // Act
            var result = await ControllerSUT.Edit(activity.EventId, activity);

            // Assert
            var viewResult = Assert.IsAssignableFrom <ViewResult>(result);

            Assert.IsAssignableFrom <Event>(viewResult.Model);
        }