public void Initialize()
{
this.mocks = new MockContainer();
this.mocks.PrepareMocks();
this.mockContext = new Mock<IUnitOfWorkData>();
this.mockContext.Setup(c => c.News).Returns(this.mocks.NewsRepositoryMock.Object);
this.controller = new NewsController(this.mockContext.Object);
this.controller.Request = new HttpRequestMessage
{
RequestUri = new Uri("http://localhost")
};
this.controller.Configuration = new HttpConfiguration();
this.controller.Configuration.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}", new { id = RouteParameter.Optional });
this.newsItem = new NewsBindingModel
{
Title = "New News",
Content = "New News Content",
PublishDate = DateTime.Now
};
this.fakeNewsCountBefore = this.mockContext.Object.News.GetAll().Count();
}
public void Listing_All_News_Should_Return_Them_Correctly()
{
var fakeNews = _mocks.NewsRepoMock.Object.All();
var mockContext = new Mock<INewsData>();
mockContext.Setup(c => c.News.All())
.Returns(fakeNews);
var newsController = new NewsController(mockContext.Object);
SetupController(newsController);
var response = newsController.GetAllNews().ExecuteAsync(CancellationToken.None).Result;
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
var newsResponse = response.Content.ReadAsAsync<IEnumerable<NewsViewModel>>()
.Result
.Select(n => n.Id)
.ToList();
var fakeNewsList = fakeNews
.OrderByDescending(n => n.PublishDate)
.Select(n => n.Id)
.ToList();
CollectionAssert.AreEqual(newsResponse, fakeNewsList);
}
public void Create_News_With_Correct_Data_Should_Return_201Created_Add_News_In_Repo_And_Return_News()
{
// Arrange
var newNews = new NewsBindingModel
{
Title = "Title 10",
Content = "Content 1010101010",
PublishDate = new DateTime(2015, 9, 1)
};
var mockContext = new Mock<INewsData>();
mockContext.Setup(c => c.News)
.Returns(this.mock.NewsRepositoryMock.Object);
var newsController = new NewsController(mockContext.Object);
this.SetupController(newsController);
// Act
var response = newsController.PostNews(newNews)
.ExecuteAsync(CancellationToken.None).Result;
// Assert
var fakeNews = this.mock.NewsRepositoryMock.Object.All().ToList();
Assert.AreEqual(HttpStatusCode.Created, response.StatusCode);
mockContext.Verify(c => c.SaveChanges(), Times.Once);
Assert.AreEqual(6, fakeNews.Count);
Assert.AreEqual(newNews.Title, fakeNews[5].Title);
Assert.AreEqual(newNews.Content, fakeNews[5].Content);
Assert.AreEqual(newNews.PublishDate, fakeNews[5].PublishDate);
}
public void List_All_News_Should_Return_200OK_And_Return_News_Correctly()
{
// Arrange
var fakeNews = this.mock.NewsRepositoryMock.Object.All();
var mockContext = new Mock<INewsData>();
mockContext.Setup(c => c.News.All())
.Returns(fakeNews);
var newsController = new NewsController(mockContext.Object);
this.SetupController(newsController);
// Act
var response = newsController.GetNews()
.ExecuteAsync(CancellationToken.None).Result;
// Assert
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
var newsResponse = response.Content
.ReadAsAsync<IEnumerable<News>>()
.Result
.ToList();
var orderedFakeNews = fakeNews
.OrderBy(n => n.PublishDate)
.ToList();
CollectionAssert.AreEqual(orderedFakeNews, newsResponse);
}
public void TestAddInvalidNews()
{
var controller = new NewsController(repoMock.Object);
SetupController(controller, "News");
var invalidNews = new NewsBindingModel { Title = "No content" };
// it's not the controller's job to validate - there is a validator
controller.ModelState.AddModelError("Content", "Required");
var result = controller.AddNews(invalidNews).ExecuteAsync(new CancellationToken()).Result;
Assert.AreEqual(HttpStatusCode.BadRequest, result.StatusCode);
}
public void CreateNewsWithWrongBindingModelShouldReturnBadRequest()
{
var controller = new NewsController(this.mock.NewsRepositoryMock.Object);
this.SetupController(controller);
var newsBind = new NewsBindingModel();
controller.ModelState.AddModelError("BadRequest", "Content can't be empty.");
var response = controller.CreateNews(newsBind).ExecuteAsync(CancellationToken.None).Result;
Assert.IsNotNull(response);
Assert.AreEqual(response.StatusCode, HttpStatusCode.BadRequest);
}
public void ModifyExistingNewsShouldReturnOk()
{
var controller = new NewsController(this.mock.NewsRepositoryMock.Object);
this.SetupController(controller);
var newsBind = new NewsBindingModel { Title = "Edit", Content = "Edit", PublishedDate = DateTime.Now };
var response = controller.EditNews(1, newsBind).ExecuteAsync(CancellationToken.None).Result;
var editedNews = this.mock.NewsRepositoryMock.Object.Find(1);
Assert.AreEqual(editedNews.Title, "Edit");
Assert.AreEqual(editedNews.Content, "Edit");
Assert.AreEqual(response.StatusCode, HttpStatusCode.OK);
}
public void CreateNews_WithIncorrectData_ShouldReturnBadRequestWithOutAddingTheNews()
{
// Arrange
var controller = new NewsController(this.dataLayerMocked);
this.SetupController(controller, "news");
// Act
var httpResponse = controller.CreateNew(null).ExecuteAsync(new CancellationToken()).Result;
var httpGetResponse = controller.GetAllNews().ExecuteAsync(new CancellationToken()).Result;
var newsFromService = httpGetResponse.Content.ReadAsAsync<News[]>().Result;
// Arrange
Assert.AreEqual(HttpStatusCode.BadRequest, httpResponse.StatusCode);
Assert.AreEqual(0, newsFromService.Count());
}
public void CreateNewsAddToRepositoryShouldReturnCreated()
{
var controller = new NewsController(this.mock.NewsRepositoryMock.Object);
this.SetupController(controller);
var newsBind = new NewsBindingModel
{
Title = "Some new news",
Content = "Content",
PublishedDate = DateTime.Now
};
var response = controller.CreateNews(newsBind).ExecuteAsync(CancellationToken.None).Result;
Assert.IsNotNull(response);
Assert.AreEqual(response.StatusCode, HttpStatusCode.Created);
}
public void CreateNewsItemWithCorrectData()
{
var repo = new RepositoryMock<News>();
repo.IsSaveCalled = false;
repo.Entities = new Dictionary<object, News>();
var news = new News()
{
Id = 1,
AuthorId = "valid",
Title = "valid",
Content = "valid",
PublishDate = DateTime.Now
};
var controller = new NewsController(repo);
this.SetupController(controller, "news");
// Act
var httpResponse = controller.CreateNews(new NewsBindingModel()
{
Id = news.Id,
AuthorId = news.AuthorId,
Title = news.Title,
Content = news.Content,
PublishDate = news.PublishDate
}).ExecuteAsync(new CancellationToken()).Result;
// Assert
Assert.AreEqual(HttpStatusCode.Created, httpResponse.StatusCode);
Assert.IsNotNull(httpResponse.Headers.Location);
var newsFromService = httpResponse.Content.ReadAsAsync<News>().Result;
Assert.AreEqual(newsFromService.Title, news.Title);
Assert.AreEqual(newsFromService.AuthorId, news.AuthorId);
Assert.AreEqual(newsFromService.Content, news.Content);
Assert.AreEqual(newsFromService.Id, news.Id);
Assert.IsNotNull(newsFromService.PublishDate);
Assert.AreEqual(repo.Entities.Count, 1);
var newsInRepo = repo.Entities.First().Value;
Assert.AreEqual(news.Title, newsInRepo.Title);
Assert.AreEqual(news.Id, newsInRepo.Id);
Assert.AreEqual(news.Content, newsInRepo.Content);
Assert.AreEqual(news.AuthorId, newsInRepo.AuthorId);
Assert.IsNotNull(newsInRepo.PublishDate);
Assert.IsTrue(repo.IsSaveCalled);
}
public void ListAllNewsShouldReturnOk()
{
var controller = new NewsController(this.mock.NewsRepositoryMock.Object);
this.SetupController(controller);
var response = controller.GetAllNews()
.ExecuteAsync(CancellationToken.None).Result;
Assert.AreEqual(
this.mock.NewsRepositoryMock.Object.All().Count(),
3,
"Counts of news are not currect.");
Assert.AreEqual(
response.StatusCode,
HttpStatusCode.OK,
"Expect status code OK.");
}
public void List_All_Items_Should_Work_Correctly()
{
var mockRepo = new Mock<IRepository<NewsRecord>>();
var news = new List<NewsRecord>()
{
new NewsRecord()
{
Title = "HopHop1",
Content = "The hoppy hop",
PublishDate = DateTime.Now
},
new NewsRecord()
{
Title = "HopHop2",
Content = "The hoppy hop2",
PublishDate = DateTime.Now.AddDays(+5)
},
new NewsRecord()
{
Title = "HopHop3",
Content = "The hoppy hop3",
PublishDate = DateTime.Now.AddDays(+10)
}
};
mockRepo.Setup(r => r.GetAll()).Returns(news.AsQueryable());
var controller = new NewsController(mockRepo.Object);
this.SetupController(controller, "NewsController");
var response = controller.GetAll().ExecuteAsync(new CancellationToken()).Result;
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
var content = response.Content.ReadAsStringAsync().Result;
var resultNews = JsonConvert.DeserializeObject<List<NewsRecord>>(content);
for (int i = 0; i < resultNews.Count; i++)
{
Assert.AreEqual(news[i].Id, resultNews[i].Id);
Assert.AreEqual(news[i].Title, resultNews[i].Title);
Assert.AreEqual(news[i].Content, resultNews[i].Content);
Assert.AreEqual(news[i].PublishDate, resultNews[i].PublishDate);
}
}
public void ListAllNewsItemsCorrectly()
{
var repo = new RepositoryMock<News>();
var news = new Dictionary<object, News>();
news.Add(1, new News()
{
Id = 1,
AuthorId = "test",
Content = "News1 Content",
Title = "News1 Title",
PublishDate = DateTime.Now
});
news.Add(2, new News()
{
Id = 2,
AuthorId = "test",
Content = "News2 Content",
Title = "News2 Title",
PublishDate = DateTime.Now
});
news.Add(3, new News()
{
Id = 3,
AuthorId = "test",
Content = "News3 Content",
Title = "News3 Title",
PublishDate = DateTime.Now
});
repo.Entities = news;
var controller = new NewsController(repo);
var result = controller.GetAllNews().ExecuteAsync(new CancellationToken()).Result;
Assert.AreEqual(HttpStatusCode.Created, result.StatusCode);
var theNews = JsonConvert.DeserializeObject<Dictionary<object, News>>(result.Content.ReadAsStringAsync().Result);
// Assert
CollectionAssert.AreEquivalent(news, theNews);
}
public void TestListAll()
{
var controller = new NewsController(repoMock.Object);
SetupController(controller, "News");
var news = new[]
{
new News { Title = "Zaglavie", Content = "dadadada" },
new News { Title = "Asdjoqwe", Content = "asodojk" }
};
repoMock.Setup(repo => repo.All()).Returns(news.AsQueryable());
var result = controller.GetAll().ExecuteAsync(new CancellationToken()).Result;
Assert.AreEqual(HttpStatusCode.OK, result.StatusCode);
var returnedNews = result.Content.ReadAsAsync<List<News>>().Result;
Assert.AreEqual(2, returnedNews.Count);
CollectionAssert.AreEquivalent(news, returnedNews);
}
public void Delete_WithExistingNews_ShouldDeleteTheNewsAndReturn200Ok()
{
// Arrange
var initialNew = new News() { Id = 1, Title = "Test news #1", Content = "Test content #1", };
var controller = new NewsController(this.dataLayerMocked);
this.SetupController(controller, "news");
// Act
this.dataLayerMocked.News.Add(initialNew);
var httpGetResponse = controller.GetAllNews().ExecuteAsync(new CancellationToken()).Result;
var newsFromService = httpGetResponse.Content.ReadAsAsync<List<News>>().Result;
var newsId = newsFromService[0].Id;
var httpDeleteResponse = controller.DeleteNewById(newsId).ExecuteAsync(new CancellationToken()).Result;
Assert.AreEqual(0, this.dataLayerMocked.News.All().Count());
Assert.AreEqual(HttpStatusCode.OK, httpDeleteResponse.StatusCode);
}
public void TestAddValidNews()
{
var controller = new NewsController(repoMock.Object);
SetupController(controller, "News");
var news = new List<News>
{
new News { Title = "Zaglavie", Content = "dadadada" },
new News { Title = "Asdjoqwe", Content = "asodojk" }
};
repoMock.Setup(repo => repo.Add(It.IsAny<News>())).Callback((News n) => news.Add(n));
var newNews = new NewsBindingModel { Title = "Teadsad", Content = "koko6ki" };
var result = controller.AddNews(newNews).ExecuteAsync(new CancellationToken()).Result;
Assert.AreEqual(HttpStatusCode.Created, result.StatusCode);
Assert.AreEqual(newNews.Title, news.Last().Title);
Assert.AreEqual(newNews.Content, news.Last().Content);
Assert.IsNotNull(news.Last().PublishDate);
}
public void CreateNews_WithCorrectData_ShouldCreateNewsAndReturn201Created()
{
// Arrange
var news = new CreateNewInputModel()
{
Title = "Test news #1",
Content = "Test content #1",
};
this.dataLayerMocked.IsChangeSaved = false;
var controller = new NewsController(this.dataLayerMocked);
this.SetupController(controller, "news");
// Act
var httpResponse = controller.CreateNew(news).ExecuteAsync(new CancellationToken()).Result;
var newsFromService = httpResponse.Content.ReadAsAsync<News>().Result;
// Arrange
Assert.IsTrue(this.dataLayerMocked.IsChangeSaved);
Assert.AreEqual(HttpStatusCode.Created, httpResponse.StatusCode);
Assert.AreEqual(news.Title, newsFromService.Title);
Assert.AreEqual(news.Content, newsFromService.Content);
}
public void Creating_News_Should_Create_And_Return_The_News()
{
var news = new List<Models.News>();
_mocks.NewsRepoMock
.Setup(r => r.Add(It.IsAny<Models.News>()))
.Callback((Models.News n) => { news.Add(n); });
var fakeNews = new NewsBindingModel
{
Title = "Sample title",
Content = "Sample content",
PublishedOn = DateTime.Now
};
var mockContext = new Mock<INewsData>();
mockContext.Setup(c => c.News)
.Returns(_mocks.NewsRepoMock.Object);
var newsController = new NewsController(mockContext.Object);
SetupController(newsController);
var response = newsController.PostNews(fakeNews).ExecuteAsync(CancellationToken.None).Result;
var newsResponse = response.Content.ReadAsAsync<NewsBindingModel>().Result;
Assert.AreEqual(response.StatusCode, HttpStatusCode.Created);
mockContext.Verify(c => c.SaveChanges(), Times.Once);
Assert.AreEqual(news.Count, 1);
//It's something
Assert.AreEqual(fakeNews.Title, newsResponse.Title);
}
public void Creating_News_With_Incorrect_Data_Should_Return_BadRequest()
{
var news = new List<Models.News>();
_mocks.NewsRepoMock
.Setup(r => r.Add(It.IsAny<Models.News>()))
.Callback((Models.News n) => { news.Add(n); });
var fakeNews = new NewsBindingModel
{
Title = null,
Content = null,
PublishedOn = DateTime.Now
};
var mockContext = new Mock<INewsData>();
mockContext.Setup(c => c.News)
.Returns(_mocks.NewsRepoMock.Object);
var newsController = new NewsController(mockContext.Object);
SetupController(newsController);
var response = newsController.PostNews(fakeNews).ExecuteAsync(CancellationToken.None).Result;
Assert.AreEqual(response.StatusCode, HttpStatusCode.BadRequest);
mockContext.Verify(c => c.SaveChanges(), Times.Never);
}
public void Modifying_Non_Existing_News_Should_Return_BadRequest()
{
var updatedNews = new NewsBindingModel
{
Title = "Update",
Content = "Update",
PublishedOn = DateTime.Now
};
var mockContext = new Mock<INewsData>();
mockContext.Setup(c => c.News)
.Returns(_mocks.NewsRepoMock.Object);
var newsController = new NewsController(mockContext.Object);
SetupController(newsController);
var response = newsController.UpdateNews(100000, updatedNews).ExecuteAsync(CancellationToken.None).Result;
Assert.AreEqual(response.StatusCode, HttpStatusCode.BadRequest);
mockContext.Verify(c => c.SaveChanges(), Times.Never);
}
public void Deleteing_Non_Existing_Item_Should_Return_BadRequest()
{
var mockContext = new Mock<INewsData>();
mockContext.Setup(c => c.News)
.Returns(_mocks.NewsRepoMock.Object);
var newsController = new NewsController(mockContext.Object);
SetupController(newsController);
var response = newsController.DeleteNews(1000000).ExecuteAsync(CancellationToken.None).Result;
Assert.AreEqual(response.StatusCode, HttpStatusCode.BadRequest);
mockContext.Verify(c => c.SaveChanges(), Times.Never);
}
private void SetupController(NewsController controller)
{
controller.Request = new HttpRequestMessage();
controller.Configuration = new HttpConfiguration();
}
public void DeleteNonExistingNewsShouldReturnNotFound()
{
var controller = new NewsController(this.mock.NewsRepositoryMock.Object);
this.SetupController(controller);
var response = controller.DeleteNews(12).ExecuteAsync(CancellationToken.None).Result;
Assert.IsNotNull(response);
Assert.AreEqual(response.StatusCode, HttpStatusCode.NotFound);
}
public void ModifyNonExistingNewsShouldReturnBadRequest()
{
var newsRepository = new Mock<IRepository<News>>();
var controller = new NewsController(newsRepository.Object);
this.SetupController(controller);
var response = controller.EditNews(3, new NewsBindingModel())
.ExecuteAsync(CancellationToken.None).Result;
Assert.IsNotNull(response);
Assert.AreEqual(response.StatusCode, HttpStatusCode.NotFound);
}
public void DeleteNonExistingNewsItem()
{
var repo = new RepositoryMock<News>();
var controller = new NewsController(repo);
this.SetupController(controller, "news");
var deleteResult = controller.DeletelNews(20).ExecuteAsync(new CancellationToken()).Result;
Assert.AreEqual(HttpStatusCode.BadRequest, deleteResult.StatusCode);
}
public void DeleteExistingNewsItem()
{
var repo = new RepositoryMock<News>();
var controller = new NewsController(repo);
this.SetupController(controller, "news");
// Act
var news = new News()
{
Id = 1,
Title = "valid",
AuthorId = "valid",
PublishDate = DateTime.Now,
Content = "valid"
};
var result = controller.CreateNews(new NewsBindingModel()
{
Id = news.Id,
AuthorId = news.AuthorId,
Title = news.Title,
Content = news.Content,
PublishDate = news.PublishDate
}).ExecuteAsync(new CancellationToken()).Result;
var theCreatedNews = repo.Entities.First().Value;
var deleteResult = controller.DeletelNews(theCreatedNews.Id).ExecuteAsync(new CancellationToken()).Result;
Assert.AreEqual(HttpStatusCode.OK, result.StatusCode);
Assert.AreEqual(repo.Entities.Count, 0);
}
public void ModifyNonExistingNewsItem()
{
var repo = new RepositoryMock<News>();
var controller = new NewsController(repo);
this.SetupController(controller, "news");
// Act
// Not added
var news = new News()
{
Id = 1,
Title = "valid",
AuthorId = "valid",
PublishDate = DateTime.Now,
Content = "valid"
};
var result = controller.EditNews(news.Id, new NewsBindingModel()
{
Id = news.Id,
AuthorId = news.AuthorId,
Title = news.Title,
Content = news.Content,
PublishDate = news.PublishDate
}).ExecuteAsync(new CancellationToken()).Result;
Assert.AreEqual(HttpStatusCode.BadRequest, result.StatusCode);
}
public void ModifyExistingNewsItemWithIncorrectData()
{
var repo = new RepositoryMock<News>();
var controller = new NewsController(repo);
this.SetupController(controller, "news");
// Act
var news = new News()
{
Id = 1,
Title = "valid",
AuthorId = "valid",
PublishDate = DateTime.Now,
Content = "valid"
};
var result = controller.CreateNews(new NewsBindingModel()
{
Id = news.Id,
AuthorId = news.AuthorId,
Title = news.Title,
Content = news.Content,
PublishDate = news.PublishDate
}).ExecuteAsync(new CancellationToken()).Result;
var theCreatedNews = repo.Entities.First().Value;
theCreatedNews.Content = null;
var editResult = controller.EditNews(theCreatedNews.Id, new NewsBindingModel()
{
Id = theCreatedNews.Id,
AuthorId = theCreatedNews.AuthorId,
Title = theCreatedNews.Title,
Content = theCreatedNews.Content,
PublishDate = theCreatedNews.PublishDate
}).ExecuteAsync(new CancellationToken()).Result;
Assert.AreEqual(HttpStatusCode.BadRequest, result.StatusCode);
}
public void ModifyExistingNewsIncorrectDataShouldReturnBadReques()
{
var controller = new NewsController(this.mock.NewsRepositoryMock.Object);
this.SetupController(controller);
controller.ModelState.AddModelError("BadRequest", "Empty binding model.");
var response = controller.EditNews(1, new NewsBindingModel())
.ExecuteAsync(CancellationToken.None).Result;
Assert.IsNotNull(response);
Assert.AreEqual(response.StatusCode, HttpStatusCode.BadRequest);
}
public void CreateNewsItemWithIncorrectData()
{
var repo = new RepositoryMock<News>();
var controller = new NewsController(repo);
this.SetupController(controller, "news");
// Act
var news = new News()
{
Id = 1,
Title = "valid",
AuthorId = "valid",
PublishDate = DateTime.Now,
Content = null
};
var result = controller.CreateNews(new NewsBindingModel()
{
Id = news.Id,
AuthorId = news.AuthorId,
Title = news.Title,
Content = news.Content,
PublishDate = news.PublishDate
}).ExecuteAsync(new CancellationToken()).Result;
// Assert
Assert.AreEqual(HttpStatusCode.BadRequest, result.StatusCode);
}
