public void Get_ShouldReturn200OKAndRetrieveAllNewsItemsCorrectly()
{
var fakeNews = this.mocks.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);
var response = newsController.Get()
.ExecuteAsync(CancellationToken.None).Result;
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
var newsResponse = response.Content
.ReadAsAsync<IEnumerable<NewsModel>>()
.Result.Select(n => n.Id)
.ToList();
var orderedFakeNews = fakeNews
.OrderByDescending(n => n.PublishDate)
.Select(fn => fn.Id)
.ToList();
CollectionAssert.AreEqual(orderedFakeNews, newsResponse);
}
protected void HandleNewsItemCommand(object sender, RepeaterCommandEventArgs e)
{
if (e.CommandName == "MarkIsUrgent")
{
NewsController controller = new NewsController();
CommandCheckBox checkbox = (CommandCheckBox)e.CommandSource;
controller.SelectNewsPost((int)e.CommandArgument);
controller.UpdateIsUrgent(checkbox.Checked);
}
}
public void AllActionShouldReturnCorrectNewsTitles()
{
var controller = new NewsController(this.EmptyOjsData);
var result = controller.All() as ViewResult;
var model = result.Model as AllNewsViewModel;
foreach (var news in model.AllNews)
{
Assert.AreEqual("News Title ", news.Title.Substring(0, 11));
}
}
public async Task ItReturns404ForNoNewsItems()
{
_repository.Setup(o => o.Get <Newsroom>(string.Empty, It.IsAny <List <Query> >()))
.ReturnsAsync(new HttpResponse(404, null, "not found"));
var controller = new NewsController(_repository.Object, _processedContentRepository.Object,
_mockRssFeedFactory.Object, _logger.Object, _config.Object, new BusinessId(BusinessId),
_filteredUrl.Object);
var response = await controller.Index(new NewsroomViewModel(), 1, MaxNumberOfItemsPerPage) as HttpResponse;
response.StatusCode.Should().Be((int)HttpStatusCode.NotFound);
}
public void SelectedNewsShouldReturnCorrectNews()
{
var controller = new NewsController(this.EmptyOjsData);
var selectedNews = this.EmptyOjsData.News.All().FirstOrDefault(x => x.IsVisible && !x.IsDeleted);
var result = controller.Selected(selectedNews.Id) as ViewResult;
var model = result.Model as SelectedNewsViewModel;
Assert.AreEqual(selectedNews.Title, model.Title);
Assert.AreEqual(selectedNews.Content, model.Content);
Assert.AreEqual(selectedNews.CreatedOn, model.TimeCreated);
}
public void InitTests()
{
this.mocks = new MockContainer();
this.mocks.PrepareMocks();
this.mockContext = new Mock<INewsData>();
this.mockContext.Setup(c => c.News).Returns(this.mocks.NewsRepositoryMock.Object);
this.newsController = new NewsController(this.mockContext.Object);
this.ConfigureController(this.newsController);
}
public void AllActionShouldReturnViewModel()
{
var controller = new NewsController(this.EmptyOjsData);
var result = controller.All() as ViewResult;
var model = result.Model as AllNewsViewModel;
Assert.AreEqual(10, model.AllNews.Count());
Assert.AreEqual(1, model.CurrentPage);
Assert.AreEqual(10, model.PageSize);
Assert.AreEqual(4, model.AllPages);
}
public void PublishNewsIsNotNullTest()
{
//Arrange
var newsController = new NewsController(newsService: null, userManager: null, mapper: null);
//Act
var result = newsController.PublishNews(1);
//Assert
Assert.IsNotNull(result);
}
public void NewsControllerPostNewsWithCorrectDataShould_ReturnCreatedNews()
{
var context = this.Context;
var testModel = this.GetTestData().First();
var newsController = new NewsController(context);
var returnedModel = (newsController.PostNews(testModel) as CreatedAtActionResult).Value as Data.Models.News;
Assert.True(this.CompareNewsExact(returnedModel, testModel));
}
public void NewsControllerPostNewsWithIncorrectDataShould_ReturnBadRequestStatusCode()
{
var context = this.Context;
var testModel = this.GetTestData().First();
var newsController = new NewsController(context);
newsController.ModelState.AddModelError("Invalid Data", "Invalid Data");
Assert.IsType <BadRequestObjectResult>(newsController.PostNews(testModel));
}
public void GetFavoriteNews_DBException_Test()
{
var newsController = new NewsController(this.mockNewsService.Object);
mockNewsService.Setup(fk => fk.GetFavoriteNews("user1")).Throws(new Exception());
var result = newsController.GetFavoriteNews("user1") as ObjectResult;
var errorMessage = Assert.IsType <string>(result.Value);
Assert.Equal("Failed to get Favorite news", errorMessage);
Assert.Equal((int)HttpStatusCode.InternalServerError, result.StatusCode);
}
public void GetCategoryNews_Test()
{
mockNewsService.Setup(fk => fk.GetNewsList(It.IsAny <string>())).Returns(getMockNewsList());
var newsController = new NewsController(this.mockNewsService.Object);
var result = newsController.GetCategoryNews("general") as ObjectResult;
var categoryNews = Assert.IsType <List <Article> >(result.Value);
Assert.Equal((int)HttpStatusCode.OK, result.StatusCode);
Assert.Equal(2, categoryNews.Count);
}
public void GetFavoriteNews_NotFound_Test()
{
var newsController = new NewsController(this.mockNewsService.Object);
mockNewsService.Setup(fk => fk.GetFavoriteNews("user1")).Returns(new List <News>());
var result = newsController.GetFavoriteNews("user1") as ObjectResult;
var favoriteNews = Assert.IsType <List <News> >(result.Value);
Assert.Equal((int)HttpStatusCode.OK, result.StatusCode);
Assert.Empty(favoriteNews);
}
public void GetFavoriteNews_UserInvalid_Test()
{
var newsController = new NewsController(this.mockNewsService.Object);
mockNewsService.Setup(fk => fk.GetFavoriteNews("user1")).Returns(new List <News>());
var result = newsController.GetFavoriteNews("") as ObjectResult;
var errorMessage = Assert.IsType <string>(result.Value);
Assert.Equal("User id is invalid!", errorMessage);
Assert.Equal((int)HttpStatusCode.BadRequest, result.StatusCode);
}
public async Task DeleteShouldReturnNotFound()
{
int newsId = 103;
var mockService = new Mock <INewsService>();
mockService.Setup(svc => svc.RemoveNews(newsId)).Throws(new NewsNotFoundException($"No news found with Id: {newsId}"));
var controller = new NewsController(mockService.Object);
var actual = await Assert.ThrowsAsync <NewsNotFoundException>(() => controller.Delete(newsId));
Assert.Equal($"No news found with Id: {newsId}", actual.Message);
}
public void Get_Success()
{
// Arrange
NewsController controller = new NewsController();
// Act
IEnumerable <News> result = controller.Get();
// Assert
Assert.IsNotNull(result);
Assert.AreEqual(15, result.Count()); // Total 10 records avail
}
public async Task Search_ShouldCallNewsServiceOnce(List <New> newsFixture, NewsSearchResource searchValue)
{
// Arrange
var mockedNewsService = createNewsServiceSearch(newsFixture);
var controller = new NewsController(_mapper, mockedNewsService.Object);
// Act
var result = await controller.SearchTitle(searchValue);
// Asset
mockedNewsService.Verify(svc => svc.SearchAsync(searchValue.Search), Times.Once());
}
public void NewsWidget_VerifySelectedItemsFunctionalityWithUseLimit()
{
string testName = System.Reflection.MethodInfo.GetCurrentMethod().Name;
string pageNamePrefix = testName + "NewsPage";
string pageTitlePrefix = testName + "News Page";
string urlNamePrefix = testName + "news-page";
int index = 1;
string sortExpession = "AsSetManually";
string url = UrlPath.ResolveAbsoluteUrl("~/" + urlNamePrefix + index);
int newsCount = 20;
string[] selectedNewsTitles = { "Title7", "Title15", "Title11", "Title3", "Title5", "Title8", "Title2", "Title16", "Title6" };
var selectedNewsItems = new NewsItem[9];
for (int i = 0; i < newsCount; i++)
{
this.serverOperationsNews.CreatePublishedNewsItem(newsTitle: NewsTitle + i, newsContent: NewsTitle + i, author: NewsTitle + i);
}
var mvcProxy = new MvcControllerProxy();
mvcProxy.ControllerName = typeof(NewsController).FullName;
var newsController = new NewsController();
newsController.Model.SelectionMode = SelectionMode.SelectedItems;
newsController.Model.DisplayMode = ListDisplayMode.Limit;
newsController.Model.SortExpression = sortExpession;
newsController.Model.ItemsPerPage = 5;
var newsManager = NewsManager.GetManager();
for (int i = 0; i < selectedNewsTitles.Count(); i++)
{
selectedNewsItems[i] = newsManager.GetNewsItems().FirstOrDefault(n => n.Title == selectedNewsTitles[i] && n.OriginalContentId != Guid.Empty);
}
//// SerializedSelectedItemsIds string should appear in the following format: "[\"ca782d6b-9e3d-6f9e-ae78-ff00006062c4\",\"66782d6b-9e3d-6f9e-ae78-ff00006062c4\"]"
newsController.Model.SerializedSelectedItemsIds =
"[\"" + selectedNewsItems[0].Id.ToString() + "\"," +
"\"" + selectedNewsItems[1].Id.ToString() + "\"," +
"\"" + selectedNewsItems[2].Id.ToString() + "\"," +
"\"" + selectedNewsItems[3].Id.ToString() + "\"," +
"\"" + selectedNewsItems[4].Id.ToString() + "\"," +
"\"" + selectedNewsItems[5].Id.ToString() + "\"," +
"\"" + selectedNewsItems[6].Id.ToString() + "\"," +
"\"" + selectedNewsItems[7].Id.ToString() + "\"," +
"\"" + selectedNewsItems[8].Id.ToString() + "\"]";
mvcProxy.Settings = new ControllerSettings(newsController);
this.VerifyCorrectNewsOnPageWithUseLimitsOption(mvcProxy, pageNamePrefix, pageTitlePrefix, urlNamePrefix, index, url, selectedNewsTitles);
}
private MvcWidgetProxy CreateNewsMvcWidget()
{
var mvcWidget = new MvcWidgetProxy();
mvcWidget.ControllerName = typeof(NewsController).FullName;
var newsController = new NewsController();
newsController.OpenInSamePage = true;
mvcWidget.Settings = new ControllerSettings(newsController);
return(mvcWidget);
}
public async void CreatePostAction_SaveModel()
{
// arrange
var mock = new Mock <IRepository <News> >();
var news = new News();
var controller = new NewsController(mock.Object);
// act
RedirectToRouteResult result = await controller.Create(news) as RedirectToRouteResult;
// assert
mock.Verify(a => a.AddAsync(news));
}
private void DeleteNewsFails(HttpStatusCode code)
{
var newsController = new NewsController(this.newsStorageMock.Object, this.inputValidation.Object, this.businessValidation.Object);
newsController.ConfigureForTesting(HttpMethod.Delete, string.Format("{0}/{1}/{2}/{3}", NewsUriRoot, City, Date, Id));
newsController.User = new GenericPrincipal(new GenericIdentity(DefaultUser.Nickname), null);
HttpResponseMessage response = newsController.Delete(City, Date, Id.ToString()).Result;
Assert.AreEqual(code, response.StatusCode);
this.newsStorageMock.Verify(storage => storage.DeleteNews(City, DateTime.Parse(Date), Id), Times.Never());
}
protected void Edit_Click(object sender, EventArgs e)
{
Uri myUri = new Uri(Request.Url.ToString());
string NewId = HttpUtility.ParseQueryString(myUri.Query).Get("ID");
/*int CategoryId = int.Parse(Session["ID"].ToString());*/
NewsController nc = new NewsController();
nc.Update(int.Parse(NewId), NewsTitle.Text, NewsSubtitle.Text, NewsDescription.Value.ToString(),
PublishedDate.Text, int.Parse(ddlAuthorId.SelectedValue), int.Parse(ddlSourceId.SelectedValue), Break_News.Checked, Youtube_Url.Text, First_AD.Text,
Second_AD.Text, Third_AD.Text, Fourth_AD.Text, Fifth_AD.Text, int.Parse(ddlLanguageId.SelectedValue), Sixth_AD.Text);
Response.Redirect("ListNews.aspx");
}
public async Task GetShouldReturnNotFound()
{
string userId = "John";
var mockService = new Mock <INewsService>();
mockService.Setup(svc => svc.GetAllNews(userId)).Throws(new NewsNotFoundException($"No news found for user: {userId}"));
var controller = new NewsController(mockService.Object);
var actual = await Assert.ThrowsAsync <NewsNotFoundException>(() => controller.Get(userId));
Assert.Equal($"No news found for user: {userId}", actual.Message);
}
public async void DeletePostAction_SaveModel()
{
// arrange
var mock = new Mock <IRepository <News> >();
int newsId = 1;
var controller = new NewsController(mock.Object);
// act
RedirectToRouteResult result = await controller.DeleteConfirmed(newsId) as RedirectToRouteResult;
// assert
mock.Verify(a => a.DeleteAsync(newsId));
}
public void NewsControllerPostNewsWithCorrectDataShould_ReturnCreatedSNews()
{
var db = this.Context;
var newsController = new NewsController(db);
//Act
var testModel = this.GetTestData().First();
var returnedModel = (newsController.PostNews(testModel) as CreatedAtActionResult).Value as News;
//Act and assert
Assert.True(this.CompareNewsExact(returnedModel, testModel));
}
public async Task Get_ShouldCallNewsServiceOnce(List <New> newsFixture)
{
// Arrange
var mockedNewsService = createNewsService(newsFixture);
var controller = new NewsController(_mapper, mockedNewsService.Object);
// Act
var result = await controller.Get();
// Asset
mockedNewsService.Verify(svc => svc.ListAsync(), Times.Once());
}
public void NewsWidget_VerifySelectedItemsFunctionalityWithSortNewsDescending()
{
int newsCount = 10;
string sortExpession = "Title DESC";
string[] selectedNewsTitles = { "Title2", "Title7", "Title5" };
string[] descendingNewsTitles = { "Title7", "Title5", "Title2" };
var selectedNewsItems = new NewsItem[3];
for (int i = 0; i < newsCount; i++)
{
this.serverOperationsNews.CreatePublishedNewsItem(newsTitle: NewsTitle + i, newsContent: NewsTitle + i, author: NewsTitle + i);
}
var newsController = new NewsController();
newsController.Model.SelectionMode = SelectionMode.SelectedItems;
newsController.Model.SortExpression = sortExpession;
var newsManager = NewsManager.GetManager();
for (int i = 0; i < selectedNewsTitles.Count(); i++)
{
selectedNewsItems[i] = newsManager.GetNewsItems().FirstOrDefault(n => n.Title == selectedNewsTitles[i] && n.OriginalContentId != Guid.Empty);
}
//// SerializedSelectedItemsIds string should appear in the following format: "[\"ca782d6b-9e3d-6f9e-ae78-ff00006062c4\",\"66782d6b-9e3d-6f9e-ae78-ff00006062c4\"]"
newsController.Model.SerializedSelectedItemsIds =
"[\"" + selectedNewsItems[0].Id.ToString() + "\"," +
"\"" + selectedNewsItems[1].Id.ToString() + "\"," +
"\"" + selectedNewsItems[2].Id.ToString() + "\"]";
var items = newsController.Model.CreateListViewModel(null, 1).Items.ToArray();
Assert.AreEqual(3, items.Length, "The count of news is not as expected");
for (int i = 0; i < items.Length; i++)
{
Assert.IsTrue(items[i].Fields.Title.Equals(descendingNewsTitles[i]), "The news with this title was not found!");
}
newsController.Model.SelectionMode = SelectionMode.AllItems;
items = newsController.Model.CreateListViewModel(null, 1).Items.ToArray();
int lastIndex = 9;
for (int i = 0; i < 10; i++)
{
Assert.IsTrue(items[i].Fields.Title.Equals(NewsTitle + lastIndex), "The news with this title was not found!");
lastIndex--;
}
}
public void NewsControllerTestSetUp()
{
controller = new NewsController(new MockTouristGuideDB());
var routeData = new RouteData();
var httpContext = MockRepository.GenerateStub <HttpContextBase>();
FormCollection formParameters = new FormCollection();
ControllerContext controllerContext =
MockRepository.GenerateStub <ControllerContext>(httpContext, routeData, controller);
controller.ControllerContext = controllerContext;
controller.ValueProvider = formParameters.ToValueProvider();
}
public async Task TestGettAllNewsReturnType()
{
var repository = new Mock <IDeletableEntityRepository <News> >();
repository.Setup(r => r.All()).Returns(new List <News>
{
new News {
Id = "1"
},
new News {
Id = "2"
},
}.AsQueryable());
var userManager = TestUserManager <ApplicationUser>();
var emailSender = new Mock <IEmailSender>();
emailSender.Setup(e => e.SendEmailAsync("123", "234", "345", "456", "567", null));
var service = new Mock <NewsService>(repository.Object);
var controller = new NewsController(service.Object, userManager, emailSender.Object);
var userMock = new Mock <ClaimsPrincipal>();
var controllerContextMock = new ControllerContext {
HttpContext = new DefaultHttpContext {
User = userMock.Object
},
};
controller.ControllerContext = controllerContextMock;
var result = controller.Add();
Assert.IsType <ViewResult>(result);
try
{
await controller.Add(new NewsInputViewModel { Title = "1234" });
}
catch (NullReferenceException)
{
Assert.True(true);
}
try
{
await controller.Add(new NewsInputViewModel { Title = "1234", Content = "12345", });
}
catch (NullReferenceException)
{
Assert.True(true);
}
}
public void DeleteNews_ShouldReturn_NotFoundResult_ForInValidId()
{
var mockINewsService = new Mock <INewsService>();
mockINewsService.Setup(x => x.DeleteNews(It.IsAny <int>())).Throws <ArgumentException>();
var newsController = new NewsController(mockINewsService.Object);
// Act
var actual = newsController.Delete(6);
//Assert
var result = Assert.IsType <NotFoundObjectResult>(actual);
}
public void NewsControllerDeleteNonExistingNewsData_ReturnedBadStatusCode()
{
//Arrenge
var db = this.Context;
var newsController = new NewsController(db);
//Act
var testDataCount = this.GetTestData().Count();
var testCode = newsController.Delete(testDataCount + 1);
Assert.IsType <BadRequestResult>(testCode);
}
public void TestDeleteUnexistingNews()
{
var controller = new NewsController(repoMock.Object);
SetupController(controller, "News");
repoMock.Setup(repo => repo.Find(It.IsAny <object>())).Returns(null as News);
var result = controller.DeleteNews(22).ExecuteAsync(new CancellationToken()).Result;
Assert.AreEqual(HttpStatusCode.BadRequest, result.StatusCode);
}
public async Task GetNewsFeedSubscription_Success()
{
subscriptionRepository.GetAsync(1).Returns(newsFeedSubscriptions[0]);
NewsController controller = new NewsController(mapper, rssFeedProvider, subscriptionRepository);
var result = await controller.GetNewsFeedSubscription(1);
var okResult = Assert.IsType <OkObjectResult>(result.Result);
var resultObject = Assert.IsType <NewsFeedSubscription>(okResult.Value);
Assert.Equal(newsFeedSubscriptions[0], resultObject);
}
public void DeleteNonExistingNewsItemByID_ShouldReturnBadRequest()
{
var repo = new RepositoryMock();
var news = GetNewsItemsNews();
repo.Entities = news;
var controller = new NewsController(repo);
SetupController(controller, "news");
// Act
var resultPostAction = controller.DeleteNewsItem(5).ExecuteAsync(new CancellationToken()).Result;
// Assert
Assert.AreEqual(HttpStatusCode.NotFound, resultPostAction.StatusCode);
}
public void DeleteNewsItemByID_WithValidData_ShouldSucceed()
{
var repo = new RepositoryMock();
var news = GetNewsItemsNews();
repo.Entities = news;
var controller = new NewsController(repo);
SetupController(controller, "news");
// Act
var resultPostAction = controller.DeleteNewsItem(news[2].Id).ExecuteAsync(new CancellationToken()).Result;
// Assert
Assert.AreEqual(HttpStatusCode.OK, resultPostAction.StatusCode);
var content = resultPostAction.Content.ReadAsStringAsync().Result;
var resultNews = JsonConvert.DeserializeObject<NewsItem>(content);
}
public void Post_ShouldReturn201CreatedAndCreateNewNewsAndReturnIt()
{
var news = new List<NewsModel>();
this.mocks.NewsRepositoryMock
.Setup(r => r.Add(It.IsAny<NewsModel>()))
.Callback((NewsModel newsModel) =>
{
news.Add(newsModel);
});
var mockContext = new Mock<INewsData>();
mockContext
.Setup(c => c.News)
.Returns(this.mocks.NewsRepositoryMock.Object);
var newsController = new NewsController(mockContext.Object);
this.SetupController(newsController);
var newNews = new PostNewsBindingModel()
{
Title = "New News",
Content = "The news is new"
};
var response = newsController.Post(newNews)
.ExecuteAsync(CancellationToken.None).Result;
Assert.AreEqual(HttpStatusCode.Created, response.StatusCode);
var returnedNews = response.Content
.ReadAsAsync<NewsModel>()
.Result;
Assert.IsTrue(returnedNews != null);
Assert.AreEqual(newNews.Title, returnedNews.Title);
Assert.AreEqual(newNews.Content, returnedNews.Content);
}
private void SetupController(NewsController newsController)
{
newsController.Request = new HttpRequestMessage();
newsController.Configuration = new HttpConfiguration();
}
public void Delete_ShouldReturn400BadRequestOnNonExistingItem()
{
var news = this.mocks.NewsRepositoryMock.Object.All().ToList();
int nonExistingNewsId = 5;
this.mocks.NewsRepositoryMock
.Setup(r => r.Delete(It.IsAny<NewsModel>()))
.Callback((NewsModel newsModel) =>
{
news.Remove(newsModel);
});
var mockContext = new Mock<INewsData>();
mockContext
.Setup(c => c.News)
.Returns(this.mocks.NewsRepositoryMock.Object);
var newsController = new NewsController(mockContext.Object);
this.SetupController(newsController);
var response = newsController.Delete(nonExistingNewsId)
.ExecuteAsync(CancellationToken.None).Result;
Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
}
private void ConfigureController(NewsController controller)
{
controller.Request = new HttpRequestMessage();
controller.Configuration = new HttpConfiguration();
}
public void Put_TryingToModifyNonExistantItemShouldReturn400BadRequest()
{
var fakeNews = this.mocks.NewsRepositoryMock.Object.All();
int nonExistingNewsId = 5;
this.mocks.NewsRepositoryMock
.Setup(r => r.Update(It.IsAny<NewsModel>()))
.Callback((NewsModel newsModel) =>
{
var news = fakeNews.FirstOrDefault(fn => fn.Id == nonExistingNewsId);
news.Title = newsModel.Title;
news.Content = newsModel.Content;
news.PublishDate = newsModel.PublishDate;
});
var mockContext = new Mock<INewsData>();
mockContext
.Setup(c => c.News)
.Returns(this.mocks.NewsRepositoryMock.Object);
var newsController = new NewsController(mockContext.Object);
this.SetupController(newsController);
var updateNews = new PutNewsBindingModel()
{
Title = "Updated news",
Content = "Updated content",
PublishDate = new DateTime(2015, 9, 5)
};
var response = newsController.Put(nonExistingNewsId, updateNews)
.ExecuteAsync(CancellationToken.None).Result;
Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
}
public void Put_ShouldModifyExistingItemAndReturn200OKOnCorrectData()
{
var fakeNews = this.mocks.NewsRepositoryMock.Object.All();
int existingNewsId = 1;
this.mocks.NewsRepositoryMock
.Setup(r => r.Update(It.IsAny<NewsModel>()))
.Callback((NewsModel newsModel) =>
{
var news = fakeNews.FirstOrDefault(fn => fn.Id == existingNewsId);
news.Title = newsModel.Title;
news.Content = newsModel.Content;
news.PublishDate = newsModel.PublishDate;
});
var mockContext = new Mock<INewsData>();
mockContext
.Setup(c => c.News)
.Returns(this.mocks.NewsRepositoryMock.Object);
var newsController = new NewsController(mockContext.Object);
this.SetupController(newsController);
var updateNews = new PutNewsBindingModel()
{
Title = "Updated news",
Content = "Updated content",
PublishDate = new DateTime(2015, 9, 5)
};
var response = newsController.Put(existingNewsId, updateNews)
.ExecuteAsync(CancellationToken.None).Result;
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
var updatedNews = response.Content
.ReadAsAsync<NewsModel>()
.Result;
Assert.AreEqual(updateNews.Title, updatedNews.Title);
Assert.AreEqual(updateNews.Content, updatedNews.Content);
Assert.AreEqual(updateNews.PublishDate, updatedNews.PublishDate);
}
public void ModifyNewsItem_WithValidData_ShouldSucceed()
{
var repo = new RepositoryMock();
var news = GetNewsItemsNews();
repo.Entities = news;
var controller = new NewsController(repo);
SetupController(controller, "news");
var newNewsItem = new NewsItem()
{
Id = 2,
Title = "fourt",
Content = "fourt",
PublishDate = DateTime.Now
};
// Act
var resultPostAction = controller.PutNewsItem(2, newNewsItem).ExecuteAsync(new CancellationToken()).Result;
// Assert
Assert.AreEqual(HttpStatusCode.OK, resultPostAction.StatusCode);
// Update retern only HttpStatusCode.OK
//var content = resultPostAction.Content.ReadAsStringAsync().Result;
//var resultNews = JsonConvert.DeserializeObject<NewsItem>(content);
//Assert.IsNotNull(resultNews.PublishDate);
//Assert.AreEqual(newNewsItem.Title, resultNews.Title);
//Assert.AreEqual(newNewsItem.Content, resultNews.Content);
}
public void GetAll_WithValidData_ShouldSucceed()
{
var repo = new RepositoryMock();
var news = GetNewsItemsNews();
repo.Entities = news;
var controller = new NewsController(repo);
SetupController(controller, "news");
// Act
var httpResponse = controller.GetNewsItems().ExecuteAsync(new CancellationToken()).Result;
var content = httpResponse.Content.ReadAsStringAsync().Result;
var resultNews = JsonConvert.DeserializeObject<List<NewsItem>>(content);
// Assert
Assert.AreEqual(HttpStatusCode.OK, httpResponse.StatusCode);
CollectionAssert.AreEqual(news, resultNews.ToArray<NewsItem>());
Assert.AreEqual(3, news.Count);
}
public void PostNewsItem_WithValidData_ShouldSucceed()
{
var repo = new RepositoryMock();
var news = GetNewsItemsNews();
repo.Entities = news;
var controller = new NewsController(repo);
SetupController(controller, "news");
var newNewsItem = new NewsItem()
{
Title = "ThirdNews",
Content = "ThirdNewsContent",
PublishDate = DateTime.Now.AddDays(8)
};
// Act
var httpResponse = controller.PostNewsItem(newNewsItem).ExecuteAsync(new CancellationToken()).Result;
var content = httpResponse.Content.ReadAsStringAsync().Result;
var resultNews = JsonConvert.DeserializeObject<NewsItem>(content);
// Assert
Assert.AreEqual(HttpStatusCode.Created, httpResponse.StatusCode);
Assert.IsNotNull(httpResponse.Headers.Location);
Assert.IsNotNull(resultNews.PublishDate);
Assert.AreEqual(newNewsItem.Title, resultNews.Title);
Assert.AreEqual(newNewsItem.Content, resultNews.Content);
}
public void PostNewsItem_WithInvalidData_ShouldReturnBadRequest()
{
var repo = new RepositoryMock();
var controller = new NewsController(repo);
SetupController(controller, "news");
var newNewsItem = new NewsItem()
{
Title = "Bad Item",
PublishDate = DateTime.Now.AddDays(8)
};
// Act
var httpResponseMessage = controller.PostNewsItem(newNewsItem).ExecuteAsync(new CancellationToken()).Result;
// Assert
Assert.AreEqual(HttpStatusCode.BadRequest, httpResponseMessage.StatusCode);
}
public void ModifyNonExistingNewsItem_ShouldReturnBadRequest()
{
var repo = new RepositoryMock();
var news = GetNewsItemsNews();
repo.Entities = news;
var controller = new NewsController(repo);
SetupController(controller, "news");
var newNewsItem = new NewsItem()
{
Id = 4,
Title = "fourt",
Content = "fourt",
PublishDate = DateTime.Now
};
// Act
var resultPostAction = controller.PutNewsItem(4, newNewsItem).ExecuteAsync(new CancellationToken()).Result;
// Assert
Assert.AreEqual(HttpStatusCode.BadRequest, resultPostAction.StatusCode);
}
public void Post_ShouldReturn400BadRequestOnNullContent()
{
var news = new List<NewsModel>();
this.mocks.NewsRepositoryMock
.Setup(r => r.Add(It.IsAny<NewsModel>()))
.Callback((NewsModel newsModel) =>
{
news.Add(newsModel);
});
var mockContext = new Mock<INewsData>();
mockContext
.Setup(c => c.News)
.Returns(this.mocks.NewsRepositoryMock.Object);
var newsController = new NewsController(mockContext.Object);
this.SetupController(newsController);
var newNews = new PostNewsBindingModel()
{
Title = "Null content",
Content = null
};
newsController.Validate(newNews);
var response = newsController.Post(newNews)
.ExecuteAsync(CancellationToken.None).Result;
Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
}
public void GetNewsItemByID_ShouldReturnBadRequest()
{
var repo = new RepositoryMock();
var controller = new NewsController(repo);
SetupController(controller, "news");
// Act
var resultPostAction = controller.GetNewsItem(1).ExecuteAsync(new CancellationToken()).Result;
// Assert
Assert.AreEqual(HttpStatusCode.NotFound, resultPostAction.StatusCode);
}
