public async Task Create_ReturnsViewResult()
        {
            // Arrange
            GetUserAsyncReturns = user1;

            Profile testProfile = new Profile
            {
                ProfileId = 1,
                UserId    = user1.Id
            };

            _context.Add(testProfile);

            UserRelationship testRelationship = new UserRelationship
            {
                UserRelationshipId = 1,
                RelatingUser       = user1,
                RelatedUser        = user2,
                RelatingProfile    = testProfile,
                RelatedProfile     = testProfile,
                Type = Relationship.Friend
            };

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

            // Act
            var result = await ControllerSUT.Create(testRelationship.UserRelationshipId);

            // Assert
            Assert.IsAssignableFrom <ViewResult>(result);
        }
Esempio n. 2
0
        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);
        }
Esempio n. 3
0
        public async Task Add_ReturnsRedirectToActionResult_WhenEventUserIsAdded()
        {
            // Arrange
            User user = _context.Users.FirstOrDefault();

            GetUserAsyncReturns = user;
            Event activity = new Event
            {
                UserId           = user.Id,
                EventDateTime    = DateTime.Now,
                EventDescription = "whatever",
                EventName        = "whatever2",
            };

            _context.Add(activity);

            _context.EventUsers.Add(new EventUser
            {
                UserId  = activity.UserId,
                EventId = activity.EventId,
            });
            await _context.SaveChangesAsync();

            // Act
            var result = await ControllerSUT.Add(activity.UserId, "url");

            // Assert
            var redirectResult = Assert.IsAssignableFrom <RedirectToActionResult>(result);

            //Assert.Equal(nameof(EventController.Index), redirectResult.ActionName);
        }
Esempio n. 4
0
        public async Task Add_ReturnsRedirectResult_WhenSuccessAndUrlNotNullOrEmpty(bool?isGift)
        {
            // Arrange
            User recipientUser = user3;

            GetUserAsyncReturns = identityUser;

            int expectedRecipientUserId = isGift.HasValue && isGift.Value ? recipientUser.Id : identityUser.Id;
            int?recipientUserId         = isGift.HasValue ? expectedRecipientUserId : default(int?);

            // Act
            var result = await ControllerSUT.Add(game1.GameId, recipientUserId, "url");

            // Assert
            var redirectResult = Assert.IsAssignableFrom <RedirectResult>(result);

            Assert.Equal("url", redirectResult.Url);
            Assert.IsAssignableFrom <string>(ControllerSUT.TempData["CartAdded"]);

            Assert.Single(await _context.CartGames.ToListAsync());

            CartGame cartItem = await _context.CartGames.FirstOrDefaultAsync();

            Assert.Equal(game1.GameId, cartItem.GameId);
            Assert.Equal(identityUser.Id, cartItem.CartUserId);
            Assert.Equal(expectedRecipientUserId, cartItem.ReceivingUserId);
        }
Esempio n. 5
0
        public async Task AddUsername_ReturnsRedirectToActionResult_WhenRelatedExists()
        {
            // Arrange
            FindByNameAsyncReturns = new User {
                Id = 1, UserName = "******"
            };
            GetUserAsyncReturns = new User {
                Id = 2, UserName = "******"
            };

            _context.UserRelationships.Add(new UserRelationship {
                RelatingUserId = 1, RelatedUserId = 2
            });

            // Act
            await _context.SaveChangesAsync();

            var result = await ControllerSUT.AddUsername("admin");

            // Assert
            var redirectToActionResult = Assert.IsAssignableFrom <RedirectToActionResult>(result);

            Assert.Equal("Index", redirectToActionResult.ActionName);
            Assert.IsAssignableFrom <string>(ControllerSUT.TempData["FriendInvite"]);
        }
Esempio n. 6
0
        public async Task RemoveConfirmed_ReturnsRedirectToAction_WhenRelationshipsAreRemoved()
        {
            // Arrange
            GetUserAsyncReturns = new User {
                Id = 1, UserName = "******"
            };
            FindByNameAsyncReturns = new User {
                Id = 2, UserName = "******"
            };

            _context.UserRelationships.Add(new UserRelationship {
                RelatingUserId = 1, RelatedUserId = 2
            });
            _context.UserRelationships.Add(new UserRelationship {
                RelatingUserId = 2, RelatedUserId = 1
            });

            // Act
            await _context.SaveChangesAsync();

            var result = await ControllerSUT.RemoveConfirmed("user1");

            // Assert
            Assert.IsAssignableFrom <RedirectToActionResult>(result);
        }
Esempio n. 7
0
        public async Task Remove_ReturnsNotFound_WhenEventIsNotFound()
        {
            // Arrange
            User  user     = _context.Users.FirstOrDefault();
            Event activity = new Event
            {
                UserId           = user.Id,
                EventDateTime    = DateTime.Now,
                EventDescription = "whatever",
                EventName        = "whatever2",
            };

            GetUserAsyncReturns = _context.Users.FirstOrDefault();
            _context.Add(new EventUser
            {
                User  = user,
                Event = activity
            });
            await _context.SaveChangesAsync();

            // Act
            var result = await ControllerSUT.Remove(666, "url");

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

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

            // Assert
            Assert.IsAssignableFrom <NotFoundResult>(result);
        }
Esempio n. 9
0
        public void Add_ReturnsViewResult()
        {
            // Arrange

            // Act
            var result = ControllerSUT.Add(profile.ProfileId.ToString());

            // Assert
            var viewResult = Assert.IsAssignableFrom <ViewResult>(result);
        }
Esempio n. 10
0
        public async Task Delete_ReturnsNotFound_WhenGameIdIsNotFound(int?reviewId)
        {
            // Arrange

            // Act
            var result = await ControllerSUT.Delete(reviewId);

            // Assert
            Assert.IsAssignableFrom <NotFoundResult>(result);
        }
Esempio n. 11
0
        public async Task Delete_ReturnsNotFound_WhenAddressIsNotFound(int?addressId)
        {
            // Arrange
            GetUserAsyncReturns = identityUser;
            // Act
            var result = await ControllerSUT.Delete(addressId);

            // Assert
            Assert.IsAssignableFrom <NotFoundResult>(result);
        }
Esempio n. 12
0
        public void Add_ReturnsViewResult()
        {
            // Arrange

            // Act
            var result = ControllerSUT.Add();

            // Assert
            var viewResult = Assert.IsAssignableFrom <ViewResult>(result);
        }
Esempio n. 13
0
        public async Task Edit_ReturnsNotFound_WhenWalletIdIsNotFound(int?walletId)
        {
            // Arrange
            GetUserAsyncReturns = identityUser;
            // Act
            var result = await ControllerSUT.Edit(walletId);

            // Assert
            Assert.IsAssignableFrom <NotFoundResult>(result);
        }
Esempio n. 14
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);
        }
Esempio n. 15
0
        public async Task Edit_ReturnsNotFound_WhenGameIdIsNotFound(int?gameId)
        {
            // Arrange

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

            // Assert
            Assert.IsAssignableFrom <NotFoundResult>(result);
        }
Esempio n. 16
0
        public async Task Create_ReturnsNotFoundResult_WhenUserIdNotFound()
        {
            // Arrange

            // Act
            var result = await ControllerSUT.Create(1, review1);

            // Assert
            Assert.IsAssignableFrom <NotFoundResult>(result);
        }
Esempio n. 17
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);
        }
Esempio n. 18
0
        public async Task RemoveConfirmed_ReturnsNotFound_WhenUsernameIsNullOrEmpty(string username)
        {
            // Arrange

            // Act
            var result = await ControllerSUT.RemoveConfirmed(username);

            // Assert
            Assert.IsAssignableFrom <NotFoundResult>(result);
        }
Esempio n. 19
0
        public async Task Index_ReturnsViewResult()
        {
            // Arrange

            // Act
            var result = await ControllerSUT.Index();

            // Assert
            var viewResult = Assert.IsAssignableFrom <ViewResult>(result);
        }
Esempio n. 20
0
        public async Task Edit_ReturnsNotFound_WhenProfileIdDoesNotMatchPostBody(int id)
        {
            // Arrange

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

            // Assert
            Assert.IsAssignableFrom <NotFoundResult>(result);
        }
Esempio n. 21
0
        public async Task Delete_ReturnsNotFound_WhenEventIsNull()
        {
            // Arrange

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

            // Assert
            Assert.IsAssignableFrom <NotFoundResult>(result);
        }
Esempio n. 22
0
        public async Task Add_ReturnsNotFoundResult_WhenGameIsNotFound()
        {
            // Arrange

            // Act
            var result = await ControllerSUT.Add(666, identityUser.Id, "url");

            // Assert
            Assert.IsAssignableFrom <NotFoundResult>(result);
        }
Esempio n. 23
0
        public async Task Add_ReturnsNotFoundResult_WhenGameIdNull(int?recipientUserId)
        {
            // Arrange

            // Act
            var result = await ControllerSUT.Add(null, recipientUserId, "url");

            // Assert
            Assert.IsAssignableFrom <NotFoundResult>(result);
        }
Esempio n. 24
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);
        }
Esempio n. 25
0
        public async Task Add_ReturnsNotFoundResult_WhenRecipientUserIdNotFound()
        {
            // Arrange
            GetUserAsyncReturns = identityUser;

            // Act
            var result = await ControllerSUT.Add(game1.GameId, 666, "url");

            // Assert
            Assert.IsAssignableFrom <NotFoundResult>(result);
        }
Esempio n. 26
0
        public async Task Edit_ReturnsNotFound_WhenEventIdNotFound()
        {
            // Arrange


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

            // Assert
            Assert.IsAssignableFrom <NotFoundResult>(result);
        }
Esempio n. 27
0
        public async Task Create_ReturnsNotFoundResult_WhenGameIdNull()
        {
            // Arrange
            GetUserAsyncReturns = identityUser;

            // Act
            var result = await ControllerSUT.Create(null, review1);

            // Assert
            Assert.IsAssignableFrom <NotFoundResult>(result);
        }
Esempio n. 28
0
        public async Task Create_ReturnsViewResult(int?gameId)
        {
            // Arrange
            GetUserAsyncReturns = identityUser;

            // Act
            var result = await ControllerSUT.Create(gameId, review1);

            // Assert
            Assert.IsAssignableFrom <RedirectToActionResult>(result);
        }
Esempio n. 29
0
        public async Task Details_ReturnsViewResult_WhenIdIsFound()
        {
            // Arrange
            // Act
            var result = await ControllerSUT.Details(166);

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

            Assert.IsAssignableFrom <Profile>(viewResult.ViewData.Model);
        }
Esempio n. 30
0
        public async Task UserWishList_NotFoundResult()
        {
            // Arrange
            GetUserAsyncReturns = new User { Id = 1, UserName = "******" };

            // Act
            var result = await ControllerSUT.Shared("fred");

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