public void AddArticleTest_ReturnsCreatedArticle()
        {
            var article = ArticleHelper.GetRandomTestArticles(1).FirstOrDefault();

            ClaimsIdentity c = new ClaimsIdentity(new ClaimsIdentity(new Claim[]
            {
                new Claim(ClaimTypes.Name, article.UserName)
            }));
            ClaimsPrincipal cp = new ClaimsPrincipal(c);
            var             mockHttpContext = new Mock <HttpContext>();

            mockHttpContext.Setup(c => c.User).Returns(cp);
            var articleRequest = ArticleHelper.CreateArticleRequest(article);

            _mockArticleService.Setup(serv => serv.CreateEntityAsync(articleRequest)).ReturnsAsync(article);
            _controller.ControllerContext.HttpContext = mockHttpContext.Object;

            var resultArticle = (_controller.AddArticle(articleRequest).Result.Result as CreatedResult)?.Value as Article;

            Assert.Equal(article.Category, resultArticle.Category);
            Assert.Equal(article.UserName, resultArticle.UserName);
            Assert.Equal(article.Content, resultArticle.Content);
            Assert.Equal(article.CreatedDate, resultArticle.CreatedDate);
            Assert.Equal(article.Id, resultArticle.Id);
            Assert.Equal(article.Title, resultArticle.Title);
        }
        public void CreateEntityAsyncTest_WithExistingArticle_ReturnsBadRequestException()
        {
            var articleRequest = ArticleHelper.CreateArticleRequest(null);
            var article        = ArrangeFor_CreateEntityAsyncTest(articleRequest);

            _mockRepository.Setup(r => r.GetAll()).ReturnsAsync(new List <Article> {
                article
            });

            var exception = Assert.ThrowsAsync <BadRequestException>(() => _articleService.CreateEntityAsync(articleRequest));

            Assert.Equal("article already exists with such title", exception.Result.Message);
        }
        public void UpdateEntityAsyncTest_WhenArticleWasNotUpdated_ReturnsResponseException()
        {
            var article        = ArticleHelper.GetRandomTestArticles(1).FirstOrDefault();
            var articleRequest = ArticleHelper.CreateArticleRequest(article);

            _mockMapper.Setup(m => m.Map <ArticleRequest, Article>(articleRequest)).Returns(article);
            _mockRepository.Setup(rep => rep.Update(article)).ReturnsAsync(false);

            var exception = Assert.ThrowsAsync <ResponseException>(() =>
                                                                   _articleService.UpdateEntityAsync(article.Id, articleRequest));

            Assert.Equal("article did not update", exception.Result.Message);
        }
        public void CreateEntityAsyncTest_WithContentMoreThan2000Symbols_ReturnsBadRequestException()
        {
            var articleRequest = ArticleHelper.CreateArticleRequest(null);
            var article        = ArrangeFor_CreateEntityAsyncTest(articleRequest);

            _mockRepository.Setup(r => r.GetAll()).ReturnsAsync(new List <Article> {
                article
            });
            articleRequest.Content = new string('*', 2500);

            var exception = Assert.ThrowsAsync <BadRequestException>(() => _articleService.CreateEntityAsync(articleRequest));

            Assert.Equal("articles bad content length", exception.Result.Message);
        }
        public void UpdateEntityAsyncTest_WithArticleRequestContentLengthMoreThan2000_ReturnsBadRequestException()
        {
            var article        = ArticleHelper.GetRandomTestArticles(1).FirstOrDefault();
            var articleRequest = ArticleHelper.CreateArticleRequest(article);

            articleRequest.Content = new string('*', 2453);
            _mockMapper.Setup(m => m.Map <ArticleRequest, Article>(articleRequest)).Returns(article);
            _mockRepository.Setup(rep => rep.Update(article)).ReturnsAsync(true);

            var exception = Assert.ThrowsAsync <BadRequestException>(() =>
                                                                     _articleService.UpdateEntityAsync(article.Id, articleRequest));

            Assert.Equal("article has  more than 2000 symbols content length", exception.Result.Message);
        }
        public void CreateEntityAsyncTest_ReturnsArticleObject()
        {
            var articleRequest = ArticleHelper.CreateArticleRequest(null);

            _mockRepository.Setup(r => r.GetAll()).ReturnsAsync(ArticleHelper.GetRandomTestArticles(10));
            var article = ArrangeFor_CreateEntityAsyncTest(articleRequest);

            var result = _articleService.CreateEntityAsync(articleRequest).Result;

            Assert.Equal(article.Category, result.Category);
            Assert.Equal(article.UserName, result.UserName);
            Assert.Equal(article.Content, result.Content);
            Assert.Equal(article.CreatedDate, result.CreatedDate);
            Assert.Equal(article.Id, result.Id);
            Assert.Equal(article.Title, result.Title);
        }
        public void UpdateEntityAsyncTest_WithArticleIdAndArticleRequest_ReturnsUpdatedArticleObject()
        {
            var article        = ArticleHelper.GetRandomTestArticles(1).FirstOrDefault();
            var articleRequest = ArticleHelper.CreateArticleRequest(article);

            _mockMapper.Setup(m => m.Map <ArticleRequest, Article>(articleRequest)).Returns(article);
            _mockRepository.Setup(rep => rep.Update(article)).ReturnsAsync(true);

            var result = _articleService.UpdateEntityAsync(article.Id, articleRequest).Result;

            Assert.Equal(article.Category, result.Category);
            Assert.Equal(article.UserName, result.UserName);
            Assert.Equal(article.Content, result.Content);
            Assert.Equal(article.CreatedDate, result.CreatedDate);
            Assert.Equal(article.Id, result.Id);
            Assert.Equal(article.Title, result.Title);
        }