public void DetailsReturnValidPost()
{
// act
var actual = (PostCommentViewModel)((ViewResult)controller.Details(1)).Model;
// assert
Assert.IsInstanceOfType(actual, typeof(PostCommentViewModel));
}
public async Task Details_PostIsNull_ReturnNotFoundResult()
{
_unitOfWork
.Setup(x => x.PostRepository.GetById(It.IsAny <int>()))
.ReturnsAsync((Post)null);
var result = await _controller.Details(It.IsAny <int>());
result
.Should()
.BeOfType <NotFoundResult>();
}
public async void GetPostDetails()
{
var expected = new Post
{
Id = 1,
Author = "author1",
Title = "Post1",
Text = "post 1 content"
};
//setup
var mockPostRepository = new Mock <IPostRepository>();
mockPostRepository.Setup(m => m.GetPost(1))
.ReturnsAsync(expected);
//act
var controller = new PostsController(mockPostRepository.Object);
var result = await controller.Details(1);
var viewResult = result as ViewResult;
//Assert
Assert.True(viewResult is ViewResult);
Assert.Equal(expected, viewResult.Model);
}
public async Task PostByUserNotInTheFriendListOfOtherNormalUserShouldReturnAccessDeniedView()
{
// Arrange
var firstUserId = "FirstUserId";
var secondUserId = "SecondUserId";
var postService = new Mock <IPostService>();
var userService = new Mock <IUserService>();
var userManager = MockManager.GetMockUserManger();
postService
.Setup(s => s.ByIdAsync(It.IsAny <int>()))
.ReturnsAsync(new Post {
UserId = firstUserId
});
userManager
.Setup(s => s.GetUserId(It.IsAny <ClaimsPrincipal>()))
.Returns(secondUserId);
userService
.Setup(s => s.CheckFriendshipStatusAsync(firstUserId, secondUserId))
.ReturnsAsync((FriendshipStatus.NotFriend, ""));
var controller = new PostsController(postService.Object, userService.Object, userManager.Object);
controller.LoginMockUser();
// Act
var result = await controller.Details(5);
// Assert
result.AssertAccessDeniedView();
}
public void Details_WithInvalidId_ReturnsNotFound()
{
var dbContext = new MockDbContext().GetContext();
controller = new PostsController(dbContext);
var result = controller.Details(1);
Assert.IsInstanceOfType(result as NotFoundResult, typeof(NotFoundResult));
}
public async Task DetailsShouldReturnNotFoundViewIfPostDoesNotExist()
{
// Arrange
var postService = new Mock <IPostService>();
var controller = new PostsController(postService.Object, null, null);
// Act
var result = await controller.Details(5);
// Assert
result.AssertNotFoundView();
}
public async Task PostController_Details_WithId_ReturnsPost()
{
ApplicationUser user = null;
Post post = null;
//Arrange
using (var context = new ApplicationDbContext(inMemoryDatabaseHelper.Options))
{
FluentData fluentData = new FluentData(context);
//create user
user = fluentData.Generate <ApplicationUser>();
await fluentData.SaveAsync(user);
post = fluentData.Generate <Post>();
//create post
post.OriginalPoster = user;
await fluentData.SaveAsync(post);
}
//Act
using (var context = new ApplicationDbContext(inMemoryDatabaseHelper.Options))
{
//Create UserRepo mock
var userRepoMock = new Mock <IUserRepository>();
userRepoMock.Setup(repo => repo.GetUserAsync(ClaimsPrincipal.Current))
.Returns(Task.FromResult(user));
var postsController = new PostsController(context,
userRepoMock.Object,
new Repository <Post>(context));
var result = await postsController.Details(post.Id);
//Assert
Assert.IsInstanceOf <ViewResult>(result);
var viewResult = result as ViewResult;
//IsAssignableFrom
Assert.IsInstanceOf <Post>(viewResult.ViewData.Model);
var model = viewResult.ViewData.Model;
Assert.That(model, Is.InstanceOf <Post>());
var readPost = model as Post;
Assert.AreEqual(readPost.Id, post.Id);
Assert.That(readPost.Title, Is.EqualTo(post.Title));
}
}
public void SingleTest()
{
//Arrange
var mockControllerContext = new Mock <ControllerContext>();
var mockSession = new Mock <HttpSessionStateBase>();
mockSession.SetupGet(s => s["RoleId"]).Returns("2");
mockControllerContext.Setup(p => p.HttpContext.Session).Returns(mockSession.Object);
PostsController postsController = new PostsController();
postsController.ControllerContext = mockControllerContext.Object;
//Act
var result = postsController.Details(1);
//Assert
Assert.IsNotNull(result);
}
public async Task DetailsShouldWork()
{
// Arrange
var mockCitiesService = new Mock <ICitiesService>();
var mockMakesService = new Mock <IMakesService>();
var mockCategoriesService = new Mock <ICategoriesService>();
var mockModelsService = new Mock <IModelsService>();
var mockVehicleCategoriesService = new Mock <IVehicleCategoriesService>();
var mockColorsService = new Mock <IColorService>();
var mockCloudinaryService = new Mock <ICloudinaryService>();
var mockUserManager = this.GetMockUserManager();
var mockCommentsService = new Mock <ICommentsService>();
var mockPostsService = new Mock <IPostsService>();
mockCommentsService
.Setup(mc => mc.GetAll())
.Returns(this.GetAllComments());
var claims = new List <Claim>()
{
new Claim("http://schemas.xmlsoap.org/ws/2005/05/identity/claims/nameidentifier", "5247d66a-84ff-4987-abb5-53b1c2e747c2"),
new Claim("http://schemas.xmlsoap.org/ws/2005/05/identity/claims/name", "*****@*****.**"),
new Claim("AspNet.Identity.SecurityStamp", "E7B2QZV5M4OIRM3ZFIVXFVGR3YULFGO7"),
new Claim("http://schemas.microsoft.com/ws/2008/06/identity/claims/role", "Admin"),
new Claim("amr", "pwd"),
};
var claimsIdentity = new ClaimsIdentity(claims);
var principal = new ClaimsPrincipal(claimsIdentity);
Thread.CurrentPrincipal = principal;
mockUserManager.Setup(mu => mu.GetUserAsync(principal))
.Returns(Task.FromResult(new ApplicationUser()
{
UserName = "******", Image = new Image()
{
Url = "testUrl"
}
}));
// Act
var controller = new PostsController(
mockPostsService.Object,
mockCitiesService.Object,
mockCategoriesService.Object,
mockMakesService.Object,
mockModelsService.Object,
mockVehicleCategoriesService.Object,
mockColorsService.Object,
mockUserManager.Object,
mockCloudinaryService.Object,
mockCommentsService.Object);
// Assert
var result = await controller.Details(1);
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsAssignableFrom <PostDetailsAndCommentsViewModel>(viewResult.ViewData.Model);
Assert.Null(model.PostDetails);
Assert.NotNull(model.CommentViewModel);
Assert.Single(model.CommentViewModel.Comments);
Assert.Equal(1, model.CommentViewModel.PostId);
Assert.Equal("MyName", model.CommentViewModel.User.UserName);
}
public void Details_WithZero_ReturnsNotFound()
{
var result = controller.Details(0);
Assert.IsInstanceOfType(result, typeof(NotFoundResult));
}
