public void ModifyExistingNewsItemWithCorrectData_ShouldModifyTheNewsItem()
{
var controller = new NewsController(this.context);
this.SetupController(controller);
var news = new NewsModel
{
Id = 555,
Title = "Fire in the motel",
Content = "The fire fighters are doing their best.",
PublishDate = DateTime.Now
};
var modifiedNews = new NewsBindingModel
{
Title = "Random title",
Content = "Random Content"
};
this.context.Add(news);
var response = controller.UpdateNews(555, modifiedNews).ExecuteAsync(CancellationToken.None).Result;
var newsInDb = controller.GetNews().ExecuteAsync(CancellationToken.None).Result
.Content.ReadAsAsync <IEnumerable <NewsModel> >().Result
.FirstOrDefault(n => n.Id == news.Id);
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
Assert.AreEqual(modifiedNews.Title, newsInDb.Title);
Assert.AreEqual(modifiedNews.Content, newsInDb.Content);
}
public IHttpActionResult Edit(int id, NewsBindingModel model)
{
var news = this.NewsRepo.All().FirstOrDefault(n => n.Id == id);
if (news == null)
{
return(this.BadRequest("Non-existing news."));
}
if (model == null)
{
return(this.BadRequest("Enter valid data."));
}
if (model.Title != null)
{
news.Title = model.Title;
}
if (model.Content != null)
{
news.Content = model.Content;
}
if (model.PublishedDate != null)
{
news.PublishedDate = model.PublishedDate;
}
this.NewsRepo.SaveChanges();
return(this.Ok(news));
}
public void ModifyExistingNewsItemWithIncorrectData_ShouldReturnBadRequest()
{
var controller = new NewsController(this.context);
this.SetupController(controller);
// Forcing validation error
controller.ModelState.AddModelError("Title", "Title should be atleast 3 symbols.");
var news = new NewsModel
{
Id = 101,
Title = "Fire in the motel",
Content = "The fire fighters are doing their best.",
PublishDate = DateTime.Now
};
var modifiedNews = new NewsBindingModel
{
Title = "1",
Content = "222"
};
this.context.Add(news);
var response = controller.UpdateNews(101, modifiedNews).ExecuteAsync(CancellationToken.None).Result;
Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
}
public void CreateNews_Should_Successfully_Add_To_Repository()
{
var fakeNews = new List<News>();
this.mocks.NewsRepositoryMock.Setup(r => r.Add(It.IsAny<News>()))
.Callback((News news) => { fakeNews.Add(news); });
var newsToAdd = new NewsBindingModel
{
Title = "News to add Title.",
Content = "News to add Content.",
PublishDate = DateTime.Now.AddDays(-3)
};
var response = this.newsController.CreateNews(newsToAdd)
.ExecuteAsync(CancellationToken.None).Result;
var createdNews = response.Content.ReadAsAsync<News>().Result;
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
Assert.AreEqual(createdNews.Title, newsToAdd.Title);
Assert.AreEqual(createdNews.Content, newsToAdd.Content);
this.mockContext.Verify(c => c.SaveChanges(), Times.Once);
Assert.AreEqual(1, fakeNews.Count);
}
public void Create_News_With_InCorrect_Data_Should_Return_400BadRequest()
{
// Arrange
var newNews = new NewsBindingModel
{
Title = "T", // invalid MinLength
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);
newsController.ModelState.AddModelError("Title", "Title MinLength is 5.");
// Act
var response = newsController.PostNews(newNews)
.ExecuteAsync(CancellationToken.None).Result;
// Assert
var fakeNews = this.mock.NewsRepositoryMock.Object.All().ToList();
Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
mockContext.Verify(c => c.SaveChanges(), Times.Never);
Assert.AreEqual(5, fakeNews.Count);
}
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 IHttpActionResult EditMock(int id, NewsBindingModel model)
{
var mockNews = MockDb.News().FirstOrDefault(n => n.Id == id);
if (mockNews == null)
{
return(this.BadRequest("Non-existing news."));
}
if (model.Title == null && model.Content == null && model.PublishedDate == null)
{
return(this.BadRequest("Enter valid data."));
}
if (model.Title != null)
{
mockNews.Title = model.Title;
}
if (model.Content != null)
{
mockNews.Content = model.Content;
}
if (model.PublishedDate != null)
{
mockNews.PublishedDate = model.PublishedDate;
}
this.NewsRepo.Update(mockNews);
return(this.Ok(mockNews));
}
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 Modify_Existing_News_With_InCorrect_Data_Should_Return_400BadRequest()
{
// Arrange
var fakeNewsToModify = this.mock.NewsRepositoryMock.Object.All().FirstOrDefault();
var newNews = new NewsBindingModel
{
Title = "T", // invalid MinLength
Content = "Modified content",
PublishDate = new DateTime(2013, 12, 12)
};
var mockContext = new Mock <INewsData>();
mockContext.Setup(c => c.News)
.Returns(this.mock.NewsRepositoryMock.Object);
var newsController = new NewsController(mockContext.Object);
this.SetupController(newsController);
newsController.ModelState.AddModelError("Title", "Title MinLength is 5.");
// Act
var response = newsController.ChangeNews(fakeNewsToModify.Id, newNews)
.ExecuteAsync(CancellationToken.None).Result;
// Assert
var fakeNews = this.mock.NewsRepositoryMock.Object.All().ToList();
Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
mockContext.Verify(c => c.SaveChanges(), Times.Never);
Assert.AreEqual(fakeNewsToModify.Title, fakeNews[0].Title);
Assert.AreEqual(fakeNewsToModify.Content, fakeNews[0].Content);
Assert.AreEqual(fakeNewsToModify.PublishDate, fakeNews[0].PublishDate);
}
public void Modify_NonExisting_News_Should_Return_400BadRequest()
{
// Arrange
int id = this.GenerateNonExistingId();
var newNews = new NewsBindingModel
{
Title = "Modified title",
Content = "Modified content",
PublishDate = new DateTime(2013, 12, 12)
};
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.ChangeNews(id, newNews)
.ExecuteAsync(CancellationToken.None).Result;
// Assert
Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
mockContext.Verify(c => c.SaveChanges(), Times.Never);
}
public void Modify_Existing_News_With_Correct_Data_Should_Return_200OK_And_Modify_News_In_Repository()
{
// Arrange
var fakeNewsToModify = this.mock.NewsRepositoryMock.Object.All().FirstOrDefault();
var newNews = new NewsBindingModel
{
Title = "Modified Title",
Content = "Modified content",
PublishDate = new DateTime(2013, 12, 12)
};
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.ChangeNews(fakeNewsToModify.Id, newNews)
.ExecuteAsync(CancellationToken.None).Result;
// Assert
var fakeNews = this.mock.NewsRepositoryMock.Object.All().ToList();
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
mockContext.Verify(c => c.SaveChanges(), Times.Once);
Assert.AreEqual(newNews.Title, fakeNews[4].Title);
Assert.AreEqual(newNews.Content, fakeNews[4].Content);
Assert.AreEqual(newNews.PublishDate, fakeNews[4].PublishDate);
}
public IHttpActionResult ChangeNews([FromUri] int id, [FromBody] NewsBindingModel model)
{
var newsInDb = this.Data.News.All()
.FirstOrDefault(n => n.Id == id);
if (newsInDb == null)
{
return(this.BadRequest("There is no news with given id."));
}
if (model == null)
{
return(this.BadRequest("No parameters to update news."));
}
if (!this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
newsInDb.Title = model.Title;
newsInDb.Content = model.Content;
newsInDb.PublishDate = model.PublishDate;
this.Data.News.Update(newsInDb);
this.Data.SaveChanges();
return(this.Ok(newsInDb));
}
public void EditNews_WithCorrectData_ShouldReturn200OkModifiesTheNewsInCorrectWay()
{
var news = MockDb.News();
var mockRepo = new Mock <IRepository <News> >();
mockRepo.Setup(n => n.Update(It.IsAny <News>())).Callback((News n) => news[CorrectNewsId - 1] = n);
var controller = new NewsController(mockRepo.Object);
SetupController(controller, "news");
var bindigModel = new NewsBindingModel()
{
Title = "Vremeto",
Content = "...",
PublishedDate = DateTime.Now.ToString("D")
};
var result = controller.EditMock(CorrectNewsId, bindigModel).ExecuteAsync(new CancellationToken()).Result;
Assert.AreEqual(HttpStatusCode.OK, result.StatusCode);
Assert.AreEqual(bindigModel.Title, news.First().Title);
Assert.AreEqual("Moda", news.Last().Title);
Assert.IsTrue(news.Count == 3);
}
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);
}
// POST api/news
public IHttpActionResult PostNews(NewsBindingModel model)
{
if (model.Title == null)
{
return(this.BadRequest("The title cannot be empty."));
}
if (model.Content == null)
{
return(this.BadRequest("The content cannot be empty."));
}
var news = new News
{
Title = model.Title,
Content = model.Content,
PublishedDate = DateTime.Now.ToString("D")
};
this.NewsRepo.Add(news);
this.NewsRepo.SaveChanges();
return(this.CreatedAtRoute("DefaultApi", new object(), news));
}
public IHttpActionResult CreateNews(NewsBindingModel model)
{
if (model == null)
{
return this.BadRequest("No data provide to create news.");
}
if (!this.ModelState.IsValid)
{
return this.BadRequest("Invalid news info.");
}
var newsToAdd = new News
{
Title = model.Title,
Content = model.Content,
PublishDate = DateTime.Now
};
this.Data.News.Add(newsToAdd);
this.Data.SaveChanges();
var newsView = NewsViewModel.CreateMethod(newsToAdd);
return this.Ok(newsView);
}
public IHttpActionResult PostNews([FromBody] NewsBindingModel m)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (m.Title == null || m.Content == null)
{
return(BadRequest());
}
var news = new News.Models.News
{
Title = m.Title,
Content = m.Content,
PublishDate = m.PublishedOn
};
Data.News.Add(news);
Data.SaveChanges();
return(this.Created("PostNews", news));
}
public IHttpActionResult UpdateNews(int id, [FromBody] NewsBindingModel m)
{
if (!Data.News.All().Any(n => n.Id == id))
{
return(BadRequest("News with the Id specified doesnt exist."));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (m.Title == null || m.Content == null)
{
return(BadRequest());
}
var news = Data.News.All().First(n => n.Id == id);
news.Title = m.Title;
news.Content = m.Content;
news.PublishDate = m.PublishedOn;
Data.SaveChanges();
return(Ok(news));
}
public IHttpActionResult PutUpdateNews([FromUri] int id, [FromBody] NewsBindingModel model)
{
if (model == null)
{
return(this.BadRequest("Invalid news model"));
}
if (!this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
var news = this.Data.News.GetById(id);
if (news == null)
{
return(this.BadRequest("No news with id: " + id));
}
news.Title = model.Title;
news.Content = model.Content;
news.PublishDate = model.PublishDate;
this.Data.SaveChanges();
var newNews = this.Data.News.GetById(id);
var newsView = new NewsViewModel()
{
Title = newNews.Title,
Content = newNews.Content,
PublishData = newNews.PublishDate
};
return(this.Ok(newsView));
}
public IHttpActionResult UpdateNews(int id, NewsBindingModel newsModel)
{
var newsToUpdate = this.NewsData.Find(id);
if (newsToUpdate == null)
{
return(this.BadRequest("There is no such news."));
}
if (newsToUpdate.UserId != this.UserIdProvider.GetUserId())
{
return(this.Unauthorized());
}
if (newsModel == null || !this.ModelState.IsValid)
{
return(this.BadRequest("The news title and content are required."));
}
newsToUpdate.Title = newsModel.Title;
newsToUpdate.Content = newsModel.Content;
if (newsModel.PublishDate != null)
{
newsToUpdate.PublishDate = newsModel.PublishDate.Value;
}
this.NewsData.Update(newsToUpdate);
this.NewsData.SaveChanges();
return(this.Ok(newsToUpdate));
}
public void PostNews_WithCorrectData_ShouldReturn201CreatedAndCreatedNews()
{
var news = MockDb.News();
var mockRepository = new Mock <IRepository <News> >();
mockRepository.Setup(r => r.Add(It.IsAny <News>())).Callback((News n) => news.Add(n));
var controller = new NewsController(mockRepository.Object);
SetupController(controller, "news");
var bindigModel = new NewsBindingModel()
{
Title = "Novina",
Content = "...",
PublishedDate = DateTime.Now.ToString("D")
};
var result = controller.PostNews(bindigModel).ExecuteAsync(new CancellationToken()).Result;
Assert.AreEqual(HttpStatusCode.Created, result.StatusCode);
Assert.AreEqual("Novini", news.First().Title);
Assert.AreEqual(bindigModel.Title, news.Last().Title);
Assert.IsTrue(news.Count == 4);
}
public IHttpActionResult PostNewNews([FromBody] NewsBindingModel model)
{
if (model == null)
{
return(this.BadRequest("Invalid news model"));
}
if (!this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
var news = new News()
{
Content = model.Content,
Title = model.Title,
PublishDate = model.PublishDate
};
this.Data.News.Add(news);
this.Data.SaveChanges();
var newsView = new NewsViewModel()
{
Title = news.Title,
Content = news.Content,
PublishData = news.PublishDate
};
return(this.Created(Uri.UriSchemeHttp, newsView));
}
public IHttpActionResult UpdateNews(int newsId, NewsBindingModel model)
{
if (model == null)
{
return this.BadRequest("No data provide to update news.");
}
if (!this.ModelState.IsValid)
{
return this.BadRequest("Invalid news info.");
}
var newsToUpdate = this.Data.News.Find(newsId);
if (newsToUpdate == null)
{
return this.BadRequest("No such news.");
}
newsToUpdate.Title = model.Title;
newsToUpdate.Content = model.Content;
if (model.PublishDate.HasValue)
{
newsToUpdate.PublishDate = model.PublishDate.Value;
}
this.Data.News.Update(newsToUpdate);
this.Data.SaveChanges();
var newsView = NewsViewModel.CreateMethod(newsToUpdate);
return this.Ok(newsView);
}
public void TestModifyUnexistingNews()
{
var controller = new NewsController(repoMock.Object);
SetupController(controller, "News");
repoMock.Setup(repo => repo.Find(It.IsAny <object>())).Returns(null as News);
var updatedNews = new NewsBindingModel {
Title = "Zaglavie", Content = "Changed content"
};
var result = controller.UpdateNews(18, updatedNews).ExecuteAsync(new CancellationToken()).Result;
Assert.AreEqual(HttpStatusCode.BadRequest, result.StatusCode);
}
public void ModifyNonExistingNewsItem_ShouldReturnBadRequest()
{
var controller = new NewsController(this.context);
this.SetupController(controller);
var modifiedNews = new NewsBindingModel
{
Title = "Fire in the motel",
Content = "The fire fighters are doing their best."
};
var response = controller.UpdateNews(1895, modifiedNews).ExecuteAsync(CancellationToken.None).Result;
Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
}
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);
}
private void SendPostReq(object sender, System.EventArgs e)
{
var title = FindViewById <EditText>(Resource.Id.editText1);
var content = FindViewById <EditText>(Resource.Id.editText2);
var model = new NewsBindingModel
{
Title = title.Text,
Content = content.Text
};
try
{
var stringContent = new StringContent(
JsonConvert.SerializeObject(model),
Encoding.UTF8,
"application/json");
var response = httpClient.PostAsync("http://10.0.2.2:56624/api/News", stringContent)
.GetAwaiter()
.GetResult();
if (response.IsSuccessStatusCode)
{
OpenSuccessDialog();
}
else
{
var result = response.Content
.ReadAsStringAsync()
.GetAwaiter()
.GetResult();
var messageModel = JsonConvert.DeserializeObject <MessageModel>(result);
OpenUnSuccessDialog(messageModel.Messages.First());
}
title.Text = string.Empty;
content.Text = string.Empty;
}
catch (Exception ex)
{
throw;
}
}
public void CreatingItemWithIncorrectData_ShouldReturnBadRequest()
{
var controller = new NewsController(this.context);
this.SetupController(controller);
// Forcing validation error
controller.ModelState.AddModelError("Title", "Title should be atleast 3 symbols.");
var newsBindingModel = new NewsBindingModel
{
Title = "1",
Content = "2222"
};
var response = controller.CreateNews(newsBindingModel).ExecuteAsync(CancellationToken.None).Result;
Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
}
public IHttpActionResult CreateNews(NewsBindingModel model)
{
if (!this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
var news = new NewsModel
{
Title = model.Title,
Content = model.Content,
PublishDate = DateTime.Now
};
this.repo.Add(news);
this.repo.SaveChanges();
return(this.Created($"api/News/{news.Id}", news));
}
public void EditNews_WithIncorrectData_ShouldReturn400BadRequest()
{
var news = MockDb.News();
var mockRepo = new Mock <IRepository <News> >();
mockRepo.Setup(n => n.Update(It.IsAny <News>())).Callback((News n) => news[CorrectNewsId - 1] = n);
var controller = new NewsController(mockRepo.Object);
SetupController(controller, "news");
//Incorect data - empty BindigModel
var bindigModel = new NewsBindingModel();
var result = controller.EditMock(CorrectNewsId, bindigModel).ExecuteAsync(new CancellationToken()).Result;
Assert.AreEqual(HttpStatusCode.BadRequest, result.StatusCode);
}
public ActionResult Add(NewsBindingModel newsModel)
{
var imageUrls = newsModel.ImageUrls.Select(url => new ImageUrl()
{
Url = url
}).ToList();
var news = new News()
{
Title = newsModel.Title,
Content = newsModel.Content
};
this.Data.News.Add(news);
this.Data.SaveChanges();
news.ImageUrls = imageUrls;
this.Data.SaveChanges();
return(this.RedirectToAction("Details", "News", new { area = "", id = news.Id }));
}
public IHttpActionResult AddNews(NewsBindingModel newsModel)
{
if (newsModel == null || !this.ModelState.IsValid)
{
return(this.BadRequest("The news title and content are required."));
}
var newsToAdd = new News
{
Title = newsModel.Title,
Content = newsModel.Content,
PublishDate = newsModel.PublishDate ?? DateTime.Now,
UserId = this.UserIdProvider.GetUserId()
};
this.NewsData.Add(newsToAdd);
this.NewsData.SaveChanges();
return(this.CreatedAtRoute("DefaultApi", new { id = newsToAdd.Id }, newsToAdd));
}
public IHttpActionResult UpdateNews(int id, NewsBindingModel model)
{
if (!this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
var newsInDb = this.repo.Find(id);
if (newsInDb == null)
{
return(this.BadRequest($"News with id {id} doesn't exists."));
}
newsInDb.Title = model.Title;
newsInDb.Content = model.Content;
this.repo.SaveChanges();
return(this.Ok());
}
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 CreateNews_Should_Return_400BadRequest_If_Data_Is_Invalid()
{
var fakeNews = new List<News>();
this.mocks.NewsRepositoryMock.Setup(r => r.Add(It.IsAny<News>()))
.Callback((News news) => { fakeNews.Add(news); });
var newsToAdd = new NewsBindingModel
{
Title = "News",
PublishDate = DateTime.Now.AddDays(-3)
};
this.newsController.Validate(newsToAdd);
var response = this.newsController.CreateNews(newsToAdd)
.ExecuteAsync(CancellationToken.None).Result;
Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
this.mockContext.Verify(c => c.SaveChanges(), Times.Never);
Assert.AreEqual(0, fakeNews.Count);
}
public void Modify_Existing_News_Item_With_Correct_Data_Modifies_The_Item()
{
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(1,updatedNews).ExecuteAsync(CancellationToken.None).Result;
Assert.AreEqual(response.StatusCode, HttpStatusCode.OK);
mockContext.Verify(c => c.SaveChanges(), Times.Once);
}
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 UpdateNews_Should_Return_400BadRequest_If_Data_Is_Invalid()
{
var fakeNews = this.mocks.NewsRepositoryMock.Object.All().ToList();
this.mocks.NewsRepositoryMock.Setup(r => r.Update(It.IsAny<News>()))
.Callback((News news) => { fakeNews[0] = news; });
var newsToUpdate = fakeNews.FirstOrDefault();
if (newsToUpdate == null)
{
Assert.Fail("Cannot perform test - No news in the repository.");
}
var updatedNews = new NewsBindingModel
{
Content = "News",
PublishDate = DateTime.Now.AddDays(-1)
};
this.newsController.Validate(updatedNews);
var response = this.newsController.UpdateNews(newsToUpdate.Id, updatedNews)
.ExecuteAsync(CancellationToken.None).Result;
Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
Assert.AreEqual(newsToUpdate.Title, newsToUpdate.Title);
Assert.AreEqual(newsToUpdate.Content, newsToUpdate.Content);
this.mockContext.Verify(c => c.SaveChanges(), Times.Never);
}
public void UpdateNews_Should_Throw_Exeption_If_Data_Is_Invalid()
{
var repository = new GenericRepository<News>(new NewsContext());
var newsToUpdate = repository.All().FirstOrDefault();
if (newsToUpdate == null)
{
Assert.Fail("Cannot run test - no news in the repository");
}
var newsModel = new NewsBindingModel
{
Title = "Upda",
Content = "Upda"
};
newsToUpdate.Title = newsModel.Title;
newsToUpdate.Content = newsModel.Content;
if (newsModel.PublishDate.HasValue)
{
newsToUpdate.PublishDate = newsModel.PublishDate.Value;
}
repository.Update(newsToUpdate);
repository.SaveChanges();
}
public void UpdateNews_Should_Successfully_Update_News()
{
var repository = new GenericRepository<News>(new NewsContext());
var newsToUpdate = repository.All().FirstOrDefault();
if (newsToUpdate == null)
{
Assert.Fail("Cannot run test - no news in the repository");
}
var newsModel = new NewsBindingModel
{
Title = "Updated Sample title.",
Content = "Updated Sample content",
PublishDate = DateTime.Now
};
newsToUpdate.Title = newsModel.Title;
newsToUpdate.Content = newsModel.Content;
if (newsModel.PublishDate.HasValue)
{
newsToUpdate.PublishDate = newsModel.PublishDate.Value;
}
repository.Update(newsToUpdate);
repository.SaveChanges();
}
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 UpdateNews_Should_Successfully_Update_News()
{
var fakeNews = this.mocks.NewsRepositoryMock.Object.All().ToList();
this.mocks.NewsRepositoryMock.Setup(r => r.Update(It.IsAny<News>()))
.Callback((News news) => { fakeNews[0] = news; });
var newsToUpdate = fakeNews.FirstOrDefault();
if (newsToUpdate == null)
{
Assert.Fail("Cannot perform test - No news in the repository.");
}
var updatedNews = new NewsBindingModel
{
Title = "UPDATED NEWS.",
Content = "UPDATED NEWS CONTENT.",
PublishDate = DateTime.Now.AddDays(-1)
};
var response = this.newsController.UpdateNews(newsToUpdate.Id, updatedNews)
.ExecuteAsync(CancellationToken.None).Result;
var updateResultContent = response.Content.ReadAsAsync<NewsViewModel>().Result;
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
Assert.AreEqual(newsToUpdate.Title, updateResultContent.Title);
Assert.AreEqual(newsToUpdate.Content, updateResultContent.Content);
this.mockContext.Verify(c => c.SaveChanges(), Times.Once);
Assert.AreEqual(2, fakeNews.Count);
}
