public ArticlesControllerTest()
{
var logFactory = LoggerFactory.Create(builder => builder.AddConsole());
var logger = logFactory.CreateLogger <ArticlesController>();
var notificationServiceFake = new NotificationServiceFake();
var databaseService = new DatabaseServiceFake();
var requestModel = new RegisterRequest()
{
Email = "*****@*****.**", Name = "Tester", Password = "******"
};
var user = new User(requestModel)
{
Id = ObjectId.GenerateNewId().ToString()
};
var currentUser = databaseService.SaveUserAsync(user).Result;
var claims = new[]
{
new Claim(ClaimTypes.Name, currentUser.Name),
new Claim(ClaimTypes.NameIdentifier, currentUser.Id)
};
var httpContextAccessFake = new HttpContextAccessorFake(claims);
currentUserId = httpContextAccessFake.HttpContext.User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
ariclesController = new ArticlesController(httpContextAccessFake, databaseService, logger);
}
public void SearchResults_WithWrongCategoryId_MustThrowHttpException()
{
//Mock articles repository
var mockedArticles = new Mock <IRepository <Article> >();
mockedArticles.Setup(repo => repo.All()).Returns(_articles.AsQueryable());
//Mock categories repository
int categoryId = 50;
var mockedCategories = new Mock <IRepository <Category> >();
mockedCategories.Setup(repo => repo.GetById(50)).Returns(_categories.FirstOrDefault(cat => cat.Id == categoryId));
//Mock data
var mockedUow = new Mock <IUowData>();
mockedUow.Setup(uow => uow.Categories).Returns(() => { return(mockedCategories.Object); });
mockedUow.Setup(uow => uow.Articles).Returns(() => { return(mockedArticles.Object); });
// Act
ArticlesController articlesController = new ArticlesController(mockedUow.Object);
var searchModel = new SearchArticlesViewModel
{
CategoryId = categoryId
};
var results = articlesController.SearchResults(searchModel) as ViewResult;
}
public void RenderDefaultViewWithCorrectViewModek_WhenPassedIdIsValid()
{
// Arrange
var articleServiceMock = new Mock <IArticleService>();
var mappingServiceMock = new Mock <IMappingService>();
var storeServiceMock = new Mock <IStoreService>();
var userServiceMock = new Mock <IUserService>();
var utilsMock = new Mock <IUtilitiesService>();
var controller = new ArticlesController(articleServiceMock.Object, mappingServiceMock.Object, storeServiceMock.Object, userServiceMock.Object, utilsMock.Object);
var controllerContextMock = new Mock <ControllerContext>();
var user = new Mock <IPrincipal>();
user.Setup(p => p.IsInRole("admin")).Returns(true);
user.SetupGet(x => x.Identity.Name).Returns("username");
controllerContextMock.SetupGet(x => x.HttpContext.User).Returns(user.Object);
controller.ControllerContext = controllerContextMock.Object;
var id = Guid.NewGuid();
var userModel = new User();
var article = new Article();
var storeItems = new List <StoreItem>();
var model = new ArticleDetailsViewModel();
userServiceMock.Setup(x => x.GetById(It.IsAny <string>())).Returns(userModel);
articleServiceMock.Setup(x => x.GetArticleById(It.IsAny <Guid>())).Returns(article);
storeServiceMock.Setup(x => x.GetItemsByKeyword(It.IsAny <string>())).Returns(storeItems);
mappingServiceMock.Setup(x => x.Map <ArticleDetailsViewModel>(It.IsAny <Article>())).Returns(model);
// Act & Assert
controller.WithCallTo(x => x.Details(id))
.ShouldRenderDefaultView()
.WithModel <ArticleDetailsViewModel>(x => x == model);
}
public void SearchResults_OnlySearchSubstring_MustReturnOnlyArticlesWhoseNameForTheCurrentCultureContainsThisSubstring()
{
//Mock repository
var mockedArticles = new Mock <IRepository <Article> >();
mockedArticles.Setup(repo => repo.All()).Returns(_articles.AsQueryable());
//Mock data
var mockedUow = new Mock <IUowData>();
mockedUow.Setup(uow => uow.Articles).Returns(() => { return(mockedArticles.Object); });
// Act
ArticlesController articlesController = new ArticlesController(mockedUow.Object);
articlesController.CurrentCulture = Culture.bg.ToString();
var searchModel = new SearchArticlesViewModel
{
SearchSubstring = "странно"
};
var results = articlesController.SearchResults(searchModel) as ViewResult;
var model = results.Model as IList <ArticleViewModel>;
Assert.AreEqual(2, model.Count);
foreach (var article in model)
{
Assert.IsTrue(article.Name.Contains(searchModel.SearchSubstring));
}
}
public void SearchResults_WithFromPriceBiggerThanToPrice_MustReturnTheSameSearchModel()
{
//Mock repository
var mockedArticles = new Mock <IRepository <Article> >();
mockedArticles.Setup(repo => repo.All()).Returns(_articles.AsQueryable());
//Mock data
var mockedUow = new Mock <IUowData>();
mockedUow.Setup(uow => uow.Articles).Returns(() => { return(mockedArticles.Object); });
// Act
ArticlesController articlesController = new ArticlesController(mockedUow.Object);
var searchModel = new SearchArticlesViewModel
{
FromPrice = 50,
ToPrice = 20
};
var results = articlesController.SearchResults(searchModel) as ViewResult;
var model = results.Model as SearchArticlesViewModel;
Assert.AreSame(model, searchModel);
}
public void SearchResults_OnlyCategoryId_MustReturnOnlyArticlesFromThisCategory()
{
//Mock repository
var mockedArticles = new Mock <IRepository <Article> >();
mockedArticles.Setup(repo => repo.All()).Returns(_articles.AsQueryable());
//Mock data
var mockedUow = new Mock <IUowData>();
mockedUow.Setup(uow => uow.Articles).Returns(() => { return(mockedArticles.Object); });
// Act
ArticlesController articlesController = new ArticlesController(mockedUow.Object);
var searchModel = new SearchArticlesViewModel
{
CategoryId = 1
};
var results = articlesController.SearchResults(searchModel) as ViewResult;
var model = results.Model as IList <ArticleViewModel>;
Assert.AreEqual(2, model.Count);
Assert.AreEqual(1, model[0].Id);
Assert.AreEqual(4, model[1].Id);
}
public void SearchResults_OnlyToPRiceTwenty_MustReturnOnlyArticlesWithPriceLowerThanTwenty()
{
//Mock repository
var mockedArticles = new Mock <IRepository <Article> >();
mockedArticles.Setup(repo => repo.All()).Returns(_articles.AsQueryable());
//Mock data
var mockedUow = new Mock <IUowData>();
mockedUow.Setup(uow => uow.Articles).Returns(() => { return(mockedArticles.Object); });
// Act
ArticlesController articlesController = new ArticlesController(mockedUow.Object);
var searchModel = new SearchArticlesViewModel
{
ToPrice = 20
};
var results = articlesController.SearchResults(searchModel) as ViewResult;
var model = results.Model as IList <ArticleViewModel>;
Assert.AreEqual(3, model.Count);
foreach (var article in model)
{
Assert.IsTrue(article.Price <= searchModel.ToPrice);
}
}
public void ArticlesFromCategory_TwoArticlesInCategory_PageSizeOne_PageNumberTwo_MustReturnSecondArticle()
{
//Mock repository
var mockedArticles = new Mock <IRepository <Article> >();
mockedArticles.Setup(repo => repo.All()).Returns(_articles.AsQueryable());
//Mock data
var mockedUow = new Mock <IUowData>();
mockedUow.Setup(uow => uow.Articles).Returns(() => { return(mockedArticles.Object); });
// Act
ArticlesController articlesController = new ArticlesController(mockedUow.Object);
articlesController.PageSize = 1;
var results = articlesController.ArticlesFromCategory(2, 2) as ViewResult;
var model = results.Model as ICollection <ArticleViewModel>;
var expectedArticle = _articles.Where(article => article.CateoryId == 2).ToList()[1];
Assert.AreEqual(1, model.Count);
Assert.AreEqual(expectedArticle.Id, model.FirstOrDefault().Id);
}
public void CallCreateArticleService_WhenModelStateIsValid()
{
// Arrange
var articleServiceMock = new Mock <IArticleService>();
var mappingServiceMock = new Mock <IMappingService>();
var storeServiceMock = new Mock <IStoreService>();
var userServiceMock = new Mock <IUserService>();
var utilsMock = new Mock <IUtilitiesService>();
var model = new CreateEditArticleViewModel();
var controller = new ArticlesController(articleServiceMock.Object, mappingServiceMock.Object, storeServiceMock.Object, userServiceMock.Object, utilsMock.Object);
var controllerContext = new Mock <ControllerContext>();
var user = new Mock <IPrincipal>();
user.Setup(p => p.IsInRole("admin")).Returns(true);
user.SetupGet(x => x.Identity.Name).Returns("username");
controllerContext.SetupGet(x => x.HttpContext.User).Returns(user.Object);
controller.ControllerContext = controllerContext.Object;
controller.ViewData.ModelState.Clear();
// Act
controller.CreateArticle(model);
// Assert
articleServiceMock.Verify(x => x.CreateArticle(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()), Times.Once);
}
public void RedirectToIndexActionOnSuccess_WhenModelStateIsValid()
{
// Arrange
var articleServiceMock = new Mock <IArticleService>();
var mappingServiceMock = new Mock <IMappingService>();
var storeServiceMock = new Mock <IStoreService>();
var userServiceMock = new Mock <IUserService>();
var utilsMock = new Mock <IUtilitiesService>();
var model = new CreateEditArticleViewModel();
var controller = new ArticlesController(articleServiceMock.Object, mappingServiceMock.Object, storeServiceMock.Object, userServiceMock.Object, utilsMock.Object);
var controllerContext = new Mock <ControllerContext>();
var user = new Mock <IPrincipal>();
user.Setup(p => p.IsInRole("admin")).Returns(true);
user.SetupGet(x => x.Identity.Name).Returns("username");
controllerContext.SetupGet(x => x.HttpContext.User).Returns(user.Object);
controller.ControllerContext = controllerContext.Object;
controller.ViewData.ModelState.Clear();
// Act & Assert
controller.WithCallTo(x => x.CreateArticle(model))
.ShouldRedirectTo(x => x.Index(null, null));
}
public void TestViewModelForDetailsView()
{
var userManager = this.GetMockUserManager();
var mockService = new Mock <IArticlesService>();
mockService.Setup(x => x.GetArticleById <DetailsArticleViewModel>("111")).Returns(() =>
{
return(new DetailsArticleViewModel {
Comments = null, Title = "Mama", Content = "Mama"
});
});
var controller = new ArticlesController(mockService.Object, userManager.Object);
var articleId = "111";
var result = controller.Details(articleId);
Assert.IsType <ViewResult>(result);
var viewResult = result as ViewResult;
Assert.IsType <DetailsArticleViewModel>(viewResult.Model);
var viewModel = viewResult.Model as DetailsArticleViewModel;
Assert.Equal("Mama", viewModel.Title);
Assert.Equal("Mama", viewModel.Content);
}
public void Index_RendersDefaultView()
{
var controller = new ArticlesController(dataContextRetriever, articleRepository, pageUrlRetriever, attachmentUrlRetriever, dependencies);
controller.WithCallTo(c => c.Index())
.ShouldRenderDefaultView();
}
public async Task AllShouldReturnModelWithCorrectInformation()
{
// ARRANGE
const string database = "AllShouldReturnModelWithCorrectInformation";
const int pageSize = 5;
const int totalArticlesCount = 25;
await using var context = new FakeDbContext(database);
await context.SeedArticles(25);
var mapper =
new Mapper(
new MapperConfiguration(conf => conf.AddProfile(new ServiceMappingProfile())));
var dataTimeService = new DateTimeService();
var configuration = new ConfigurationBuilder()
.AddInMemoryCollection(new KeyValuePair <string, string>[]
{
new KeyValuePair <string, string>("Articles:PageSize", pageSize.ToString()),
})
.Build();
var articleService = new ArticleService(context, mapper, dataTimeService);
var controller = new ArticlesController(articleService, mapper, configuration);
// ACT
ViewResult result = Assert.IsType <ViewResult>(await controller.All());
ArticleListingViewModel model = Assert.IsType <ArticleListingViewModel>(result.Model);
// ASSERT
Assert.Equal(pageSize, model.Articles.Count());
Assert.Equal(totalArticlesCount, model.Total);
}
public void Setup()
{
_articleRepositoryMock = new Mock <IArticleRepository>()
{
DefaultValue = DefaultValue.Mock
};
_unitOfWorkMock = new Mock <IUnitOfWork>();
_unitOfWorkMock.Setup(m => m.ArticleRepository).Returns(_articleRepositoryMock.Object);
_articleParams = new ArticleParams();
_testArticles = new List <Article>()
{
new ArticleBuilder().WithId(1).WithCode("Article1").WithName1("1st article").WithSupplierId("sup1").WithSupplierReference("sup1 ref 1").WithUnit("ST").WithPurchasePrice(10.00M).Build(),
new ArticleBuilder().WithId(2).WithCode("Article2").WithName1("2nd article").WithSupplierId("sup2").WithSupplierReference("sup1 ref 2").WithUnit("ST").WithPurchasePrice(20.00M).Build(),
new ArticleBuilder().WithId(3).WithCode("Article3").WithName1("3rd article").WithSupplierId("sup3").WithSupplierReference("sup2 ref 1").WithUnit("ST").WithPurchasePrice(30.00M).Build()
}.AsEnumerable();
var articlesPagedList = new PagedList <Article>(items: _testArticles, count: 3, pageNumber: 1, pageSize: 10);
_articleRepositoryMock
.Setup(m => m.GetArticlesAsync(_articleParams))
.ReturnsAsync(articlesPagedList);
_articleRepositoryMock
.Setup(m => m.GetArticleByIdAsync(2))
.ReturnsAsync(articlesPagedList[1]);
var mapper = new Mapper(new MapperConfiguration(cfg => cfg.AddProfile <AutoMapperProfiles>()));
_articlesController = new ArticlesController(_listQueryMock.Object, _singleQueryMock.Object, _createCommandMock.Object, _updateCommandMock.Object, _deleteCommandMock.Object);
}
public void ReturnPartialViewWithCorrectModel_WhenInputParamsAreValid()
{
// Arrange
var articleServiceMock = new Mock <IArticleService>();
var mappingServiceMock = new Mock <IMappingService>();
var storeServiceMock = new Mock <IStoreService>();
var userServiceMock = new Mock <IUserService>();
var utilsMock = new Mock <IUtilitiesService>();
var controller = new ArticlesController(articleServiceMock.Object, mappingServiceMock.Object, storeServiceMock.Object, userServiceMock.Object, utilsMock.Object);
var controllerContext = new Mock <ControllerContext>();
var user = new Mock <IPrincipal>();
user.Setup(p => p.IsInRole("admin")).Returns(true);
user.SetupGet(x => x.Identity.Name).Returns("username");
controllerContext.SetupGet(x => x.HttpContext.User).Returns(user.Object);
controller.ControllerContext = controllerContext.Object;
var userModel = new User();
var article = new Article();
var model = new ArticleDetailsViewModel();
articleServiceMock.Setup(x => x.DeleteComment(It.IsAny <string>()));
userServiceMock.Setup(x => x.GetById(It.IsAny <string>())).Returns(userModel);
articleServiceMock.Setup(x => x.GetArticleById(It.IsAny <Guid>())).Returns(article);
mappingServiceMock.Setup(x => x.Map <ArticleDetailsViewModel>(article)).Returns(model);
// Act & Assert
controller.WithCallTo(x => x.DeleteComment(Guid.NewGuid(), "id"))
.ShouldRenderPartialView("_CommentBoxPartial")
.WithModel <ArticleDetailsViewModel>(x => x == model);
}
private ArticlesController SetupController(IForumSystemData forumSystemData)
{
var articlesController = new ArticlesController(forumSystemData);
this.SetupController(articlesController);
return(articlesController);
}
public void GetAll_When16ArticlesInDb_ShouldReturn10Articles()
{
Article[] articles = this.GenerateValidTestArticles(16);
var repo = Mock.Create <IRepository <Article> >();
Mock.Arrange(() => repo.All())
.Returns(() => articles.AsQueryable());
var data = Mock.Create <IArticlesData>();
Mock.Arrange(() => data.Articles)
.Returns(() => repo);
var controller = new ArticlesController(data);
this.SetupController(controller);
var actionResult = controller.Get();
var response = actionResult.ExecuteAsync(CancellationToken.None).Result;
var actual = response.Content.ReadAsAsync <IEnumerable <ArticleDataModel> >().Result.Select(a => a.ID).ToList();
var expected = articles.AsQueryable()
.OrderByDescending(a => a.DateCreated)
.Take(10)
.Select(a => a.ID).ToList();
CollectionAssert.AreEquivalent(expected, actual);
}
public async void HighlightArticleNotPublishedTest()
{
var controller = new ArticlesController(_context, _userManager);
var article = _articleDTOs.First(a => a.IsHighlighted == false && a.IsPublished == false);
Assert.True(article.IsHighlighted == false);
Assert.True(article.HighlightedAt == null);
Assert.True(article.IsPublished == false);
Assert.True(article.PublishedAt == null);
//POST TEST (Highlight)
var result = await controller.PostHighlightArticle(article.Id);
Assert.IsType <BadRequestResult>(result);
//GET TEST (Article unchanged)
var result2 = await controller.GetArticle(article.Id);
var objectResult2 = Assert.IsType <OkObjectResult>(result2);
var model = Assert.IsAssignableFrom <ArticleDTO>(objectResult2.Value);
Assert.True(article.IsHighlighted == false);
Assert.True(article.HighlightedAt == null);
}
public async void PutImageTest()
{
var controller = new ArticlesController(_context, _userManager);
var article = _articleDTOs.First(a => a.IsHighlighted == true);
ImageDTO newImage = new ImageDTO()
{
Name = "New Image",
Base64 = article.Images.First().Base64
}
;
//POST TEST (Highlight)
var result = await controller.PutImage(article.Id, newImage);
var objectResult = Assert.IsType <OkObjectResult>(result);
var model = Assert.IsAssignableFrom <ImageDTO>(objectResult.Value);
newImage.Id = model.Id;
Assert.Equal(newImage, model);
//GET TEST (Image added to Article)
article.Images.Add(newImage);
var result2 = await controller.GetArticle(article.Id);
var objectResult2 = Assert.IsType <OkObjectResult>(result2);
var model2 = Assert.IsAssignableFrom <ArticleDTO>(objectResult2.Value);
Assert.Equal(article, model2);
}
public async void Index_Success()
{
// Arrange
var articleAdapterMock = new Mock <IArticleAdapter>();
articleAdapterMock
.Setup(aa => aa.GetArticlesByPage(1, 20))
.Returns(Task.FromResult(new FilteredModels <Article>
{
Items = new List <Article>
{
new Article {
Id = 1, Text = "Test1", CommentsCount = 0
},
new Article {
Id = 2, Text = "Test2", CommentsCount = 0
}
}
}));
var controller = new ArticlesController(articleAdapterMock.Object);
// Act
var actual = await controller.Index(1);
// Assert
var view = Assert.IsType <ViewResult>(actual);
var model = Assert.IsType <ArticlesViewModel>(view.Model);
Assert.Null(model.Error);
Assert.Equal(2, model.Articles.Items.Count);
}
public async void PostArticleInvalidIdTest()
{
var controller = new ArticlesController(_context, _userManager);
var article = new ArticleDTO(_articleDTOs.First());
int originalId = article.Id;
article.Lead = "Change";
//Id does not match article Id
var result = await controller.PostArticle(article.Id + 1, article);
Assert.IsType <BadRequestResult>(result);
//Id matches but does not exist
article.Id = 40;
var result2 = await controller.PostArticle(article.Id, article);
Assert.IsType <NotFoundResult>(result2);
//GET TEST (Article unchanged)
var result3 = await controller.GetArticle(originalId);
var objectResult3 = Assert.IsType <OkObjectResult>(result3);
var model = Assert.IsAssignableFrom <ArticleDTO>(objectResult3.Value);
Assert.Equal(_articleDTOs.First(), model);
}
public async Task Index_ReturnsAllArticles()
{
// Arrange
var articleModel = new ArticleConciseViewModel()
{
Id = 1, Title = "First"
};
bool methodCalled = false;
var mockRepository = new Mock <IAdminArticlesService>();
mockRepository.Setup(s => s.GetAllArticlesAsync())
.ReturnsAsync(new[] { articleModel })
.Callback(() => methodCalled = true);
var userRepository = new Mock <IAdminUsersService>();
userRepository.Setup(repo => repo.GetAuthorsAsync())
.Callback(() => methodCalled = true);
var controller = new ArticlesController(userRepository.Object, mockRepository.Object);
// Act
var result = await controller.Index();
// Assert
Assert.IsInstanceOfType(result, typeof(ViewResult));
var resultView = result as ViewResult;
Assert.IsNotNull(resultView.Model);
Assert.IsInstanceOfType(resultView.Model, typeof(IEnumerable <ArticleConciseViewModel>));
Assert.IsTrue(methodCalled);
}
public void CallGetUserByIdMethod_WhenInputParamsAreValid()
{
// Arrange
var articleServiceMock = new Mock <IArticleService>();
var mappingServiceMock = new Mock <IMappingService>();
var storeServiceMock = new Mock <IStoreService>();
var userServiceMock = new Mock <IUserService>();
var utilsMock = new Mock <IUtilitiesService>();
var controller = new ArticlesController(articleServiceMock.Object, mappingServiceMock.Object, storeServiceMock.Object, userServiceMock.Object, utilsMock.Object);
var controllerContext = new Mock <ControllerContext>();
var user = new Mock <IPrincipal>();
user.Setup(p => p.IsInRole("admin")).Returns(true);
user.SetupGet(x => x.Identity.Name).Returns("username");
controllerContext.SetupGet(x => x.HttpContext.User).Returns(user.Object);
controller.ControllerContext = controllerContext.Object;
var userModel = new User();
var article = new Article();
var model = new ArticleDetailsViewModel();
articleServiceMock.Setup(x => x.DeleteComment(It.IsAny <string>()));
userServiceMock.Setup(x => x.GetById(It.IsAny <string>())).Returns(userModel);
articleServiceMock.Setup(x => x.GetArticleById(It.IsAny <Guid>())).Returns(article);
mappingServiceMock.Setup(x => x.Map <ArticleDetailsViewModel>(article)).Returns(model);
// Act
controller.DeleteComment(Guid.NewGuid(), "some id");
// Assert
userServiceMock.Verify(x => x.GetById(It.IsAny <string>()), Times.Once);
}
public void ControlerShouldNotPostNewArticle()
{
var article = new Article
{
Title = "Web API Unit Testing",
URL = "https://chsakell.com/web-api-unit-testing",
Author = "Chris Sakellarios",
DateCreated = DateTime.Now,
Contents = null
};
var _articlesController = new ArticlesController(articleService)
{
Configuration = new HttpConfiguration(),
Request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("http://localhost/api/articles")
}
};
_articlesController.Configuration.MapHttpAttributeRoutes();
_articlesController.Configuration.EnsureInitialized();
_articlesController.RequestContext.RouteData = new HttpRouteData(
new HttpRoute(), new HttpRouteValueDictionary {
{ "Controller", "Articles" }
});
_articlesController.ModelState.AddModelError("Contents", "Contents is required field");
var result = _articlesController.PostArticle(article) as InvalidModelStateResult;
Assert.That(result.ModelState.Count, Is.EqualTo(1));
Assert.That(result.ModelState.IsValid, Is.EqualTo(false));
}
public void ArticleLikedBeforeCheckTest()
{
var likes = new List <ArticleLike>()
{
new ArticleLike()
{
ArticleId = 5, UserId = "testUser"
}
}.AsQueryable();
var mockSet = new Mock <DbSet <ArticleLike> >();
ConfigMockSet <ArticleLike>(mockSet, likes);
var mockContext = new Mock <ArticleContext>();
mockContext.Setup(c => c.Likes).Returns(mockSet.Object);
var identityMock = new Mock <ControllerContext>();
identityMock.SetupGet(p => p.HttpContext.User.Identity.Name).Returns("testUser");
identityMock.SetupGet(p => p.HttpContext.Request.IsAuthenticated).Returns(true);
ArticlesController controlller = new ArticlesController(new TestConfigProvider(), mockContext.Object);
controlller.ControllerContext = identityMock.Object;
PrivateObject prio = new PrivateObject(controlller);
var result = prio.Invoke("IsArticleLikedBefore", 5);
Assert.AreEqual(true, result);
}
public void ControlerShouldPostNewArticle()
{
var article = new Article
{
Title = "Web API Unit Testing",
URL = "https://chsakell.com/web-api-unit-testing",
Author = "Chris Sakellarios",
DateCreated = DateTime.Now,
Contents = "Unit testing Web API.."
};
var _articlesController = new ArticlesController(articleService)
{
Configuration = new HttpConfiguration(),
Request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("http://localhost/api/articles")
}
};
_articlesController.Configuration.MapHttpAttributeRoutes();
_articlesController.Configuration.EnsureInitialized();
_articlesController.RequestContext.RouteData = new HttpRouteData(
new HttpRoute(), new HttpRouteValueDictionary {
{ "_articlesController", "Articles" }
});
var result = _articlesController.PostArticle(article) as CreatedAtRouteNegotiatedContentResult <Article>;
Assert.That(result.RouteName, Is.EqualTo("DefaultApi"));
Assert.That(result.Content.ID, Is.EqualTo(result.RouteValues["id"]));
Assert.That(result.Content.ID, Is.EqualTo(randomArticles.Max(a => a.ID)));
}
public void ControlerShouldPutUpdateFirstArticle()
{
var _articlesController = new ArticlesController(articleService)
{
Configuration = new HttpConfiguration(),
Request = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri("http://localhost/api/articles/1")
}
};
IHttpActionResult updateResult = _articlesController.PutArticle(1, new Article()
{
ID = 1,
Title = "ASP.NET Web API feat. OData",
URL = "http://t.co/fuIbNoc7Zh",
Contents = @"OData is an open standard protocol.."
}) as IHttpActionResult;
Assert.That(updateResult, Is.TypeOf <StatusCodeResult>());
StatusCodeResult statusCodeResult = updateResult as StatusCodeResult;
Assert.That(statusCodeResult.StatusCode, Is.EqualTo(HttpStatusCode.NoContent));
Assert.That(randomArticles.First().URL, Is.EqualTo("http://t.co/fuIbNoc7Zh"));
}
public async Task RandomShouldReturnViewModelWithCorrecArticle()
{
// ARRANGE
const int requestedEntityIndex = 3;
const int requestedEntityId = requestedEntityIndex + 1;
var configuration = new ConfigurationBuilder()
.AddInMemoryCollection(new KeyValuePair <string, string>[]
{
new KeyValuePair <string, string>("Articles:PageSize", "5"),
})
.Build();
var articleController =
new ArticlesController(new FakeArticleService(), null, configuration)
.WithClaimPrincipal("TEST_USERNAME");
var fakeRandomValueProvider = new FakeRandomValueProvider
{
NextValue = requestedEntityIndex
};
// ACT
var actionResult =
Assert.IsType <ViewResult>(await articleController.Random(fakeRandomValueProvider));
var model = Assert.IsType <ArticleDetailsServiceModel>(actionResult.Model);
// ASSERT
Assert.Equal(requestedEntityId, model.Id);
}
public async Task Index_ReturnsAViewResult_WithAnArticle()
{
// Arrange
var config = new Mock <IConfiguration>();
MockHttpMessageHandler mockHttp = new MockHttpMessageHandler();
mockHttp.When($"https://deliver.kontent.ai/975bf280-fd91-488c-994c-2f04416e5ee3/items?elements.url_pattern=on_roasts&depth=1&language={CultureInfo.CurrentCulture}&system.type=article")
.Respond("application/json", File.ReadAllText(Path.Combine(Environment.CurrentDirectory, $"on_roasts.json")));
IDeliveryClient client = DeliveryClientBuilder.WithProjectId("975bf280-fd91-488c-994c-2f04416e5ee3").WithDeliveryHttpClient(new DeliveryHttpClient(mockHttp.ToHttpClient())).WithTypeProvider(new CustomTypeProvider()).Build();
var factory = new Mock <IDeliveryClientFactory>();
factory.Setup(m => m.Get()).Returns(client);
ArticlesController controller = new ArticlesController(config.Object, factory.Object);
// Act
var result = await controller.Show("on_roasts");
// Assert
var viewResult = Assert.IsType <ViewResult>(result);
var viewModel = Assert.IsType <Article>(viewResult.ViewData.Model);
Assert.Equal("On Roasts", viewModel.Title);
}
public async Task IndexReturnsAViewResultWithAListOfArticlesByTitle()
{
string search = "ok";
var mockUnit = new Mock <IUnitOfWork>();
mockUnit.Setup(u => u.ArticlesRepository);
var mockServ = new Mock <IArticleService>();
mockServ.Setup(u => u.GetArticleByTitle(It.IsAny <string>())).Returns(GetTestUsersByTitleAsync(search));
// ArticleService articleService = new ArticleService(mockUnit.Object);
using (var context = new ApplicationDbContext(options))
{
var http = new Mock <IHttpContextAccessor>();
var controller = new ArticlesController(mockServ.Object, context, http.Object);
// Act
var result = controller.Index(search);
// Assert
var viewResult = Assert.IsType <ViewResult>(result.Result);
var model = Assert.IsAssignableFrom <Task <IEnumerable <Article> > >(viewResult.Model);
// var model =await Assert.IsType< Task<IEnumerable<Article>>>((Task<IEnumerable<Article>>)viewResult.ViewData.Model);
Assert.Equal(GetTestUsersByTitleAsync(search).Result.Count(), model.Result.Count());
}
}
public void AllWithoutParametersShouldRenderCorrectView()
{
this.articlesServiceMock.Setup(x => x.AllBySearchQuery(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()))
.Returns(new List<ArticleViewModel>()
{
new ArticleViewModel(),
new ArticleViewModel(),
});
this.controller = new ArticlesController(this.articlesServiceMock.Object, this.civilizationsServiceMock.Object, this.categoriesServiceMock.Object);
this.controller.WithCallTo(x => x.All(null, null, null, null, null, null))
.ShouldRenderView("All");
}
public void DetailedShouldRenderCorrectView()
{
this.articlesServiceMock.Setup(x => x.GetById(It.IsAny<int>()))
.Returns(new DetailedArticleViewModel()
{
Title = ArticleTitle,
Content = ArticleContent
});
this.controller = new ArticlesController(this.articlesServiceMock.Object, this.civilizationsServiceMock.Object, this.categoriesServiceMock.Object);
this.controller.WithCallTo(x => x.Detailed(5))
.ShouldRenderView("Detailed");
}
public void DetailedShouldReturnCorrectModel()
{
this.articlesServiceMock.Setup(x => x.GetById(It.IsAny<int>()))
.Returns(new DetailedArticleViewModel()
{
Title = ArticleTitle,
Content = ArticleContent
});
this.controller = new ArticlesController(this.articlesServiceMock.Object, this.civilizationsServiceMock.Object, this.categoriesServiceMock.Object);
this.controller.WithCallTo(x => x.Detailed(5))
.ShouldRenderView("Detailed")
.WithModel<DetailedArticleViewModel>(
viewModel =>
{
Assert.AreEqual(ArticleTitle, viewModel.Title);
Assert.AreEqual(ArticleContent, viewModel.Content);
}).AndNoModelErrors();
}
public void DetailShouldThrowWhenIdIsNull()
{
this.articlesServiceMock.Setup(x => x.GetById(It.IsAny<int>()))
.Returns(new DetailedArticleViewModel()
{
Title = ArticleTitle,
Content = ArticleContent
});
this.controller = new ArticlesController(this.articlesServiceMock.Object, this.civilizationsServiceMock.Object, this.categoriesServiceMock.Object);
var ex = Assert.Throws<HttpException>(() => this.controller.WithCallTo(x => x.Detailed(null)));
Assert.IsTrue(ex.Message.Contains("Detailed article requires id"));
}
public void DetailShoudThrowWhenArticleWithSuchIdDoesNotExist()
{
this.articlesServiceMock.Setup(x => x.GetById(5))
.Returns(new DetailedArticleViewModel()
{
Title = ArticleTitle,
Content = ArticleContent
});
this.controller = new ArticlesController(this.articlesServiceMock.Object, this.civilizationsServiceMock.Object, this.categoriesServiceMock.Object);
var ex = Assert.Throws<HttpException>(() => this.controller.WithCallTo(x => x.Detailed(6)));
Assert.IsTrue(ex.Message.Contains("No such article exists in the database"));
}
