public void BlogListInvalidPageTest()
{
var controller = new BlogController();
var result = controller.Index(-100);
Assert.IsNotNull(result);
result = controller.Index(0);
Assert.IsNotNull(result);
}
public async Task IndexTest_ReturnsViewWithBlogPostList()
{
// Arrange
var res = false;
IEnumerable <BlogPost> objectsList = new List <BlogPost>
{
new BlogPost {
Title = "mock article 1", Description = "Hi", PostedDate = DateTime.Now
},
new BlogPost {
Title = "mock article 2", Description = "Hi", PostedDate = DateTime.Now
}
};
blogPostServMock.Setup(repo => repo.GetAllPost()).Returns(Task.FromResult(objectsList));
// Act
var result = await blogController.Index();
// Assert
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsAssignableFrom <IEnumerable <BlogPost> >(viewResult.ViewData.Model);
Assert.Equal(2, model.Count());
if (model.Count() == 2)
{
res = true;
}
File.AppendAllText("../../../../output_revised.txt",
"IndexTest_ReturnsViewWithBlogPostList="
+ res.ToString() + "\n");
}
public void Index_Ok()
{
//Act
var response = _blogController.Index();
//Assert
Assert.True(response.CastActionResult <ViewResult>() != null);
}
public void TestNotExistingBlog()
{
// Run index method on controller for non-existing blog entry
var controller = new BlogController();
// Verify that http error was returned
Assert.IsInstanceOfType(controller.Index(99), typeof(HttpNotFoundResult));
}
public void BlogListNullPageTest()
{
var controller = new BlogController();
var result = controller.Index(null);
Assert.IsNotNull(result);
}
public void Index_RequestOfView_ReturnedViewIndex()
{
var mock = new Mock <IMainService <TopicDTO> >();
mock.Setup(a => a.GetAllElements()).Returns(new List <TopicDTO>());
var controller = new BlogController(mock.Object);
var result = controller.Index() as ViewResult;
Assert.AreEqual("Index", result.ViewName);
}
public void Viewbag_Values_Are_Correct_Index_BlogController()
{
// Arrange
BlogController cut = new BlogController(_postRepository);
// Act
var result = cut.Index() as ViewResult;
// Assert
_postRepository.AssertWasCalled(pr => pr.RecentPosts(10));
Assert.IsNotNull(result.Model);
}
public void Index_RequestOfView_ViewIsNotNull()
{
var mock = new Mock <IMainService <TopicDTO> >();
mock.Setup(a => a.GetAllElements()).Returns(new List <TopicDTO>());
var controller = new BlogController(mock.Object);
var result = controller.Index() as ViewResult;
Assert.IsNotNull(result);
}
public void CheckDisplayBlogsView()
{
//Arrange
var mockBlogRepo = new Mock <IBlogRepository>();
BlogController blogctrl = new BlogController(mockBlogRepo.Object);
//Act
var result = blogctrl.Index() as ViewResult;
//Assert
Assert.IsNotNull(result);
}
public async Task TestIndexReturnsView()
{
var mockBlogEntryService = new Mock <IBlogEntryService>();
var controller = new BlogController(mockBlogEntryService.Object);
var result = await controller.Index();
Assert.IsType <ViewResult>(result);
var viewResult = (ViewResult)result;
Assert.NotNull(viewResult.ViewData.Model);
Assert.Equal("Index", viewResult.ViewName);
}
public void Index()
{
// Arrange
Mock <IBlogRepository <Post> > mockRepo = new Mock <IBlogRepository <Post> >();
BlogController controller = new BlogController(mockRepo.Object);
// Act
ViewResult result = controller.Index() as ViewResult;
//Assert
Assert.IsNotNull(result);
}
public async Task BlogIndex()
{
var mockCtx = new Mock <BloggingDbContext>();
var mockOpt = new Mock <IOptions <GameSetting> >();
var controller = new BlogController(mockCtx.Object, mockOpt.Object);
var result = controller.Index();
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsAssignableFrom <IEnumerable <Blog> >(viewResult.ViewData.Model);
//Assert.True(3, model.Count());
}
public async Task TestIndexQueriesBlogServiceForCorrectPage()
{
var mockBlogEntryService = new Mock <IBlogEntryService>();
var controller = new BlogController(mockBlogEntryService.Object);
var result = await controller.Index(5);
Assert.IsType <ViewResult>(result);
var viewResult = (ViewResult)result;
var modelData = viewResult.ViewData.Model;
Assert.NotNull(modelData);
Assert.IsType <IEnumerable <Entry> >(modelData);
}
public void TestDemoDataGeneration()
{
// Run index method on controller
var controller = new BlogController();
var result = controller.Index(null) as ViewResult;
// Check that result's model is of correct type
Assert.IsNotNull(result);
Assert.IsNotNull(result.Model);
var resultList = result.Model as IEnumerable <BlogItem>;
Assert.IsNotNull(resultList);
// Check if proper demo data has been created
Assert.AreEqual(3, resultList.Count());
}
public async Task IndexShouldReturnCorrectViewModel()
{
var currentUser = new ApplicationUser {
UserName = "******"
};
var mockService = new Mock <IBlogService>();
mockService.Setup(x => x.ExtraxtAllPosts(currentUser, null))
.ReturnsAsync(new List <PostViewModel>
{
new PostViewModel
{
Id = Guid.NewGuid().ToString(),
Title = "Test",
}
});
var mockUserManager = new Mock <UserManager <ApplicationUser> >(
new Mock <IUserStore <ApplicationUser> >().Object,
new Mock <IOptions <IdentityOptions> >().Object,
new Mock <IPasswordHasher <ApplicationUser> >().Object,
new IUserValidator <ApplicationUser> [0],
new IPasswordValidator <ApplicationUser> [0],
new Mock <ILookupNormalizer>().Object,
new Mock <IdentityErrorDescriber>().Object,
new Mock <IServiceProvider>().Object,
new Mock <ILogger <UserManager <ApplicationUser> > >().Object);
mockUserManager.Setup(x => x.GetUserAsync(It.IsAny <ClaimsPrincipal>()))
.ReturnsAsync(currentUser);
var controller =
new BlogController(mockService.Object, mockUserManager.Object);
var result = await controller.Index(1, null);
Assert.IsType <ViewResult>(result);
var viewResult = result as ViewResult;
Assert.IsType <BlogViewModel>(viewResult.Model);
var viewModel = viewResult.Model as BlogViewModel;
Assert.Single(viewModel.Posts);
Assert.Equal("Test", viewModel.Posts.ToList()[0].Title);
}
public void Index_ReturnsAViewResult_WithTheLatestPost()
{
// Arrange
var mockRepo = new Mock <IRepository <Post> >();
mockRepo.Setup(repo => repo.GetAll()).Returns(GetTestPosts());
var controller = new BlogController(mockRepo.Object);
// Act
var result = controller.Index();
// Assert
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsAssignableFrom <IEnumerable <BlogViewModel> >(
viewResult.ViewData.Model);
Assert.Single(model);
}
public void IndexReturnsAllBlogs()
{
//Arrange
//Defining get all method
_repository.Setup(x => x.getAll()).Returns(testBlogs);
//Setting up controller in Mock repository
var controller = new BlogController(_repository.Object, _manager);
//Act
var result = (ViewResult)controller.Index();
//Assert
CollectionAssert.AllItemsAreInstancesOfType((ICollection)result.ViewData.Model, typeof(Blog));
Assert.IsNotNull(result, "View result is null");
var blogs = result.ViewData.Model as List <Blog>;
Assert.AreEqual(2, blogs.Count, "Wrong number of products");
}
public void TestIndexMethod()
{
List <Blog> fakeBlogs = new List <Blog> {
new Blog {
Text = "Blog1", Title = "Hey"
},
new Blog {
Text = "Blog2", Title = "Hey"
}
};
repos.Setup(x => x.GetAllBlogs()).Returns(fakeBlogs);
var controller = new BlogController(repos.Object);
var result = (ViewResult)controller.Index();
CollectionAssert.AllItemsAreInstancesOfType((ICollection)result.ViewData.Model, typeof(Blog));
Assert.IsNotNull(result, "ViewResult is null");
var op = result.ViewData.Model as List <Blog>;
Assert.AreEqual(2, op.Count, "Got wrong number of blogs");
}
public void IndexReturnsAListOfBlogEntriesWithCorrectUrls()
{
const int id1 = 1;
const string title1 = "My first blog Entry";
const string content1 = "I love blogging, it is so cool";
var mockBlogEntry1 = new BlogEntryBuilder()
.WithId(id1)
.WithTitle(title1)
.WithContent(content1)
.Build();
const int id2 = 2;
const string title2 = "I'm still in to this";
const string content2 = "I'm still enjoying my blogging";
var mockBlogEntry2 = new BlogEntryBuilder()
.WithId(id2)
.WithTitle(title2)
.WithContent(content2)
.Build();
const int id3 = 3;
const string title3 = "OK!";
const string content3 = "Ok, I'm done!";
var mockBlogEntry3 = new BlogEntryBuilder()
.WithId(id3)
.WithTitle(title3)
.WithContent(content3)
.Build();
var blogRepository = new Mock <IBlogRepository>();
blogRepository
.Setup(p => p.GetAllBlogEntries())
.Returns(new List <BlogEntry>
{
mockBlogEntry1,
mockBlogEntry2,
mockBlogEntry3
});
var blogController = new BlogController(blogRepository.Object);
var viewResult = blogController.Index();
var blogEntries = (List <BlogEntry>)viewResult.ViewData.Model;
var blogEntry1 = blogEntries[0];
Assert.AreEqual(id1, blogEntry1.Id);
Assert.AreEqual(title1, blogEntry1.Title);
Assert.AreEqual(content1, blogEntry1.Content);
const string url1 = "my-first-blog-entry";
Assert.AreEqual(url1, blogEntry1.Url);
var blogEntry2 = blogEntries[1];
Assert.AreEqual(id2, blogEntry2.Id);
Assert.AreEqual(title2, blogEntry2.Title);
Assert.AreEqual(content2, blogEntry2.Content);
const string url2 = "Im-still-in-to-this";
Assert.AreNotEqual(url2, blogEntry2.Url);
const string url2A = "im-still-in-to-this";
Assert.AreEqual(url2A, blogEntry2.Url);
var blogEntry3 = blogEntries[2];
Assert.AreEqual(id3, blogEntry3.Id);
Assert.AreEqual(title3, blogEntry3.Title);
Assert.AreEqual(content3, blogEntry3.Content);
const string url3 = "ok";
Assert.AreEqual(url3, blogEntry3.Url);
Assert.AreNotEqual(title3, blogEntry3.Url);
}
public void Index_Returns_A_View()
{
var result = controller.Index();
Assert.IsType <ViewResult>(result);
}
public void Index_Returns_View_Result()
{
var result = underTest.Index();
Assert.IsType <ViewResult>(result);
}
public void IndexReturnsAListOfBlogEntriesWithCorrectUrls()
{
var mockBlogEntry1 = new Mock <BlogEntry>();
const int id1 = 1;
const string title1 = "My first blog Entry";
const string content1 = "I love blogging, it is so cool";
mockBlogEntry1.SetupGet(x => x.Id).Returns(id1);
mockBlogEntry1.SetupGet(x => x.Title).Returns(title1);
mockBlogEntry1.SetupGet(x => x.Content).Returns(content1);
const int id2 = 2;
const string title2 = "I'm still in to this";
const string content2 = "I'm still enjoying my blogging";
var mockBlogEntry2 = new Mock <BlogEntry>();
mockBlogEntry2.SetupGet(x => x.Id).Returns(id2);
mockBlogEntry2.SetupGet(x => x.Title).Returns(title2);
mockBlogEntry2.SetupGet(x => x.Content).Returns(content2);
const int id3 = 3;
const string title3 = "OK!";
const string content3 = "Ok, I'm done!";
var mockBlogEntry3 = new Mock <BlogEntry>();
mockBlogEntry3.SetupGet(x => x.Id).Returns(id3);
mockBlogEntry3.SetupGet(x => x.Title).Returns(title3);
mockBlogEntry3.SetupGet(x => x.Content).Returns(content3);
var blogRepository = new Mock <IBlogsRepository>();
blogRepository
.Setup(p => p.GetAllBlogEntries())
.Returns(new List <BlogEntry> {
mockBlogEntry1.Object, mockBlogEntry2.Object, mockBlogEntry3.Object
});
BlogController blogController = new BlogController((IBlogsRepository)blogRepository.Object);
ViewResult viewResult = blogController.Index() as ViewResult;
List <BlogEntry> blogEntries = (System.Collections.Generic.List <BlogEntry>)viewResult.ViewData.Model;
BlogEntry blogEntry1 = blogEntries[0];
Assert.AreEqual(id1, blogEntry1.Id);
Assert.AreEqual(title1, blogEntry1.Title);
const string url1 = "my-first-blog-entry";
Assert.AreEqual(url1, blogEntry1.Url);
Assert.AreEqual(content1, blogEntry1.Content);
BlogEntry blogEntry2 = blogEntries[1];
Assert.AreEqual(id2, blogEntry2.Id);
Assert.AreEqual(title2, blogEntry2.Title);
const string url2 = "im-still-in-to-this";
Assert.AreEqual(url2, blogEntry2.Url);
Assert.AreEqual(content2, blogEntry2.Content);
BlogEntry blogEntry3 = blogEntries[2];
Assert.AreEqual(id3, blogEntry3.Id);
Assert.AreEqual(title3, blogEntry3.Title);
const string url3 = "ok";
Assert.AreEqual(url3, blogEntry3.Url);
Assert.AreEqual(content3, blogEntry3.Content);
}
