public void Check_CommentTitle_Valid(int textLength)
{
string text = GetStringWithDesiredLength(textLength);
var validator = new CommentValidator();
string[] errors;
Assert.True(validator.Validate(Comment.Create(new CommentState { Text = text }), out errors));
}
public void Configure(IApplicationBuilder app, IApplicationLifetime applicationLifetime, ILoggerFactory loggerFactory)
{
////app.UseCors("MyPolicy");
// initialize endpoint
var configurationManager = new ConfigurationManager(this.config);
var endpointInitializer = new EndpointInitializer(configurationManager);
var endpointConfiguration = new EndpointConfiguration(configurationManager.NsbEndpointName);
endpointInitializer.Initialize(endpointConfiguration, true);
applicationLifetime.ApplicationStopping.Register(this.OnShutdown);
// start endpoint
this.endpointInstance = Endpoint.Start(endpointConfiguration).GetAwaiter().GetResult();
// initialize validator
var commentValidator = new CommentValidator();
// initialize logger
var legger = loggerFactory.AddLog4Net().CreateLogger("Web");
app.UseOwin(x => x.UseNancy(opt => opt.Bootstrapper = new Bootstrapper(
this.endpointInstance,
commentValidator,
legger)));
}
public void TestGetAll()
{
var firstComment = CommentBuilder.New().WithContent("FirstComment").Build();
var secondComment = CommentBuilder.New().WithContent("SecondComment").Build();
var thirdComment = CommentBuilder.New().WithContent("ThirdComment").Build();
var resultValidationFirst = new CommentValidator().Validate(firstComment);
var resultValidationSecond = new CommentValidator().Validate(secondComment);
var resultValidationThird = new CommentValidator().Validate(thirdComment);
// Conhecimento MemoryCache
CacheItemPolicy policy = new CacheItemPolicy();
policy.AbsoluteExpiration = DateTimeOffset.Now.AddSeconds(120);
memoryCache.Add("firstComment", firstComment, policy);
memoryCache.Add("secondComment", secondComment, policy);
memoryCache.Add("thirdComment", thirdComment, policy);
Assert.IsTrue(3 == memoryCache.GetCount());
// Produção através dos métodos
new CreateComment().CreateNewRegister(firstComment);
new CreateComment().CreateNewRegister(secondComment);
new CreateComment().CreateNewRegister(thirdComment);
List <Comment> listComments = new GetComment().GetAllRegister();
Assert.IsTrue(3 == listComments.Count);
}
public ActionResult <Comment> Post(Guid autorId, string content, Guid publicationId)
{
var resultValidation = new UserExistValidator().Validate(autorId);
if (!resultValidation.IsValid)
{
return(BadRequest(resultValidation.Errors));
}
var autor = userRepository.GetById(autorId);
resultValidation = new PublicationExistValidator().Validate(publicationId);
if (!resultValidation.IsValid)
{
return(BadRequest(resultValidation.Errors));
}
Comment comment = new Comment(autor, content, publicationId);
resultValidation = new CommentValidator().Validate(comment);
if (!resultValidation.IsValid)
{
return(BadRequest(resultValidation.Errors));
}
commentRepository.Create(comment);
return(CreatedAtAction("Get", new { id = comment.Id }, comment));
}
public void DefaultValidation_CommentThatIsNull_ShouldThrowException()
{
ICommentValidator commentValidator = new CommentValidator();
Action action = () => commentValidator.DefaultValidation(null as Comment);
action.Should().Throw <NullReferenceException>().WithMessage("Comment can not be null");
}
public async Task <Guid> CreateCommentReplyAsync(Guid userId, string slug, Guid parentEntityId, Guid replyingToComment, Comment comment, CancellationToken cancellationToken)
{
if (Guid.Empty == userId)
{
throw new ArgumentOutOfRangeException(nameof(userId));
}
if (string.IsNullOrEmpty(slug))
{
throw new ArgumentOutOfRangeException(nameof(slug));
}
var now = _systemClock.UtcNow.UtcDateTime;
var userCanPerformAction = await _permissionsService.UserCanPerformActionAsync(userId, slug, AddCommentRole, cancellationToken);
if (!userCanPerformAction)
{
_logger.LogError($"Error: CreateCommentAsync - User:{0} does not have access to group:{1}", userId, slug);
throw new SecurityException($"Error: User does not have access");
}
var threadId = await _commentCommand.GetThreadIdForComment(replyingToComment, cancellationToken);
if (!threadId.HasValue)
{
_logger.LogError($"Error: CreateCommentReplyAsync - Cannot find the original comment when replying to comment:{0} in discussion: {1}", replyingToComment, parentEntityId);
throw new SecurityException($"Error: User does not have access");
}
var entityId = Guid.NewGuid();
var commentDto = new CommentDto()
{
EntityId = entityId,
Content = comment.Content,
CreatedAtUTC = now,
CreatedBy = userId,
ModifiedBy = null,
ModifiedAtUTC = null,
FlaggedAsSpam = false,
InReplyTo = replyingToComment,
ThreadId = threadId,
IsDeleted = false,
DiscussionId = parentEntityId
};
var validator = new CommentValidator();
var validationResult = await validator.ValidateAsync(commentDto, cancellationToken);
if (validationResult.Errors.Count > 0)
{
throw new ValidationException(validationResult);
}
var createdComment = await _commentCommand.CreateCommentAsync(commentDto, cancellationToken);
_ = Task.Run(() => _commentNotificationService.SendNotificationToCommentCreatorAsync(userId, replyingToComment, cancellationToken), cancellationToken);
return(createdComment);
}
public CommentValidatorTests()
{
_workItemRepository = Substitute.For <IWorkItemRepository>();
_workItemRepository.GetById(1).Returns(new WorkItem());
_workItemRepository.GetById(0).Returns <WorkItem>(value => null);
_validator = new CommentValidator(_workItemRepository);
}
public void DefaultValidation_TopicThatIsNull_ShouldThrowException()
{
ICommentValidator commentValidator = new CommentValidator();
Action action = () => commentValidator.DefaultValidation(new Comment()
{
DatePosted = DateTime.Now.AddDays(-5), MainBody = "yadayada", User = new User()
});
action.Should().Throw <NullReferenceException>().WithMessage("Comment must have a Topic");
}
public void DefaultValidation_DatePostedCanNotBeInFuture_ShouldThrowException()
{
ICommentValidator commentValidator = new CommentValidator();
Action action = () => commentValidator.DefaultValidation(new Comment()
{
DatePosted = DateTime.Now.AddDays(5), MainBody = "yadayada", Topic = new Topic(), User = new User()
});
action.Should().Throw <ArgumentException>().WithMessage("DatePosted can not be in the future");
}
public void DefaultValidation_CommentCanNotBeEmptyOrNull_ShouldThrowException()
{
ICommentValidator commentValidator = new CommentValidator();
Action action = () => commentValidator.DefaultValidation(new Comment()
{
DatePosted = DateTime.Now.AddDays(-5), Topic = new Topic(), User = new User()
});
action.Should().Throw <ArgumentException>().WithMessage("Comment must not be empty");
}
public Comment(BlogEntry blogEntry, string name, string emailAddress, string commentText)
{
BlogEntry = blogEntry;
Name = name;
EmailAddress = emailAddress;
CommentText = commentText;
DateWritten = DateTime.Now;
var commentValidator = new CommentValidator();
commentValidator.ValidateAndThrow(this);
}
public void CommentValidator_ThrowsInvalidValueLength()
{
CommentModel model = new CommentModel
{
PostId = new Guid("9834d7b9-618d-435b-b86e-d9e861111738"),
Value = "too small"
};
CommentValidator validator = new CommentValidator();
validator.Validate(model);
}
public PostItemService(
IPostItemRepository postItemRepository,
ICommentRepository commentRepository,
PostValidator postValidator,
CommentValidator commentValidator)
{
this.postItemRepository = postItemRepository;
this.commentRepository = commentRepository;
this.postValidator = postValidator;
this.commentValidator = commentValidator;
}
public void CommentValidator_ThrowsEmptyOrNullValue()
{
CommentModel model = new CommentModel
{
PostId = new Guid("9834d7b9-618d-435b-b86e-d9e861111738"),
Value = String.Empty
};
CommentValidator validator = new CommentValidator();
validator.Validate(model);
}
public void TestValidationCommentWithInvalidTopic()
{
var okUser = UserBuilder.New().Build();
new UserRepository().Create(okUser);
var badComment1 = CommentBuilder.New().WithContent(" ").Build();
var resultValidation2 = new CommentValidator().Validate(badComment1);
Assert.False(resultValidation2.IsValid);
}
public void TestValidationCommentWithValidResult()
{
var okUser = UserBuilder.New().Build();
new UserRepository().Create(okUser);
var okComment = CommentBuilder.New().Build();
var resultValidation1 = new CommentValidator().Validate(okComment);
Assert.True(resultValidation1.IsValid);
}
public void TestValidationCommentWithInvalidPublicationId()
{
var okUser = UserBuilder.New().Build();
new UserRepository().Create(okUser);
var badComment1 = CommentBuilder.New().WithPublicationId(Guid.Parse("00000000-0000-0000-0000-000000000000")).Build();
var resultValidation2 = new CommentValidator().Validate(badComment1);
Assert.False(resultValidation2.IsValid);
}
public Comment EditCommentVotes(string command, int commentId)
{
try
{
var comment = _context.Comments.SingleOrDefault(com => com.Id == commentId);
comment = CommentValidator.ValidateCommand(comment, command);
_context.Comments.Update(comment);
_context.SaveChanges();
return(comment);
}
catch (Exception)
{
throw;
}
}
public static void Initialize(TestContext testContext)
{
ApplicationUserValidator = new ApplicationUserValidator();
FollowerValidator = new FollowerValidator();
CredentialValidator = new CredentialValidator();
CredentialTypeValidator = new CredentialTypeValidator();
RoleValidator = new RoleValidator();
UserRoleValidator = new UserRoleValidator();
RolePermissionValidator = new RolePermissionValidator();
PermissionValidator = new PermissionValidator();
MemeValidator = new MemeValidator();
CommentValidator = new CommentValidator();
Hasher = new Pbkdf2Hasher();
SaltGenerator = new RandomSaltGenerator();
}
public ActionResult <Comment> Put(Guid id, string content)
{
var resultValidation = new CommentExistValidator().Validate(id);
if (!resultValidation.IsValid)
{
return(BadRequest(resultValidation.Errors));
}
Comment oldComment = commentRepository.GetById(id);
Comment newComment = new Comment(id, oldComment.Autor, content, oldComment.PublicationId);
resultValidation = new CommentValidator().Validate(newComment);
if (!resultValidation.IsValid)
{
return(BadRequest(resultValidation.Errors));
}
return(Ok(commentRepository.Update(newComment)));
}
public void TestGetById()
{
var comment = CommentBuilder.New().WithId(new Guid()).Build();
var resultValidation = new CommentValidator().Validate(comment);
// Conhecimento MemoryCache
CacheItemPolicy policy = new CacheItemPolicy();
policy.AbsoluteExpiration = DateTimeOffset.Now.AddSeconds(60);
memoryCache.Add("commentGetId", comment, policy);
Comment commentGet = (Comment)memoryCache["commentGetId"];
Assert.IsTrue(commentGet.Id == Guid.Parse("00000000-0000-0000-0000-000000000000"));
// Produção através dos métodos
new CreateComment().CreateNewRegister(comment);
var idGet = new GetComment().GetRegisterById(comment.Id);
Assert.IsNotNull(idGet);
}
public IActionResult CreateComment(string content, Guid postId, Guid userId)
{
var post = getByIdPostUseCase.GetById(postId);
var user = getByIdUserUseCase.GetById(userId);
if (post == null && user == null)
{
return(BadRequest());
}
var comment = new Domain.Entities.Comment(content, post, user);
var validationResult = new CommentValidator().Validate(comment);
if (!validationResult.IsValid)
{
return(BadRequest(validationResult.Errors));
}
addCommentUseCase.Add(comment);
return(new OkObjectResult(comment));
}
private Comment CreateComment(Document inDocument)
{
using var documentContext = this.ApiServiceContext.CreateApiDocumentContext(inDocument);
var inComment = documentContext.GetResource <Comment>();
var apiCommentResource = inDocument.GetResource();
if (apiCommentResource?.Relationships != null)
{
// Author foreign key (optional)
if (apiCommentResource.Relationships.TryGetRelationship("author", out var apiCommentAuthorRelationship))
{
if (apiCommentAuthorRelationship.IsToOneRelationship())
{
var apiCommentAuthorToOneRelationship = (ToOneRelationship)apiCommentAuthorRelationship;
var apiCommentAuthorId = Convert.ToInt64(apiCommentAuthorToOneRelationship.Data.Id);
inComment.AuthorId = apiCommentAuthorId;
}
}
// Article foreign key (required)
if (apiCommentResource.Relationships.TryGetRelationship("article", out var apiCommentArticleRelationship))
{
if (apiCommentArticleRelationship.IsToOneRelationship())
{
var apiCommentArticleToOneRelationship = (ToOneRelationship)apiCommentArticleRelationship;
var apiCommentArticleId = Convert.ToInt64(apiCommentArticleToOneRelationship.Data.Id);
inComment.ArticleId = apiCommentArticleId;
}
}
}
var validator = new CommentValidator();
validator.ValidateAndThrow(inComment);
var outComment = this.BloggingRepository.CreateComment(inComment);
return(outComment);
}
public CommentShould()
{
this.configuration = new CommentValidator();
}
public async Task UpdateCommentAsync(Guid userId, string slug, Guid parentEntityId, Guid commentId, Comment comment, byte[] rowVersion, CancellationToken cancellationToken)
{
if (Guid.Empty == userId)
{
throw new ArgumentOutOfRangeException(nameof(userId));
}
if (string.IsNullOrEmpty(slug))
{
throw new ArgumentOutOfRangeException(nameof(slug));
}
if (Guid.Empty == parentEntityId)
{
throw new ArgumentOutOfRangeException(nameof(parentEntityId));
}
if (Guid.Empty == commentId)
{
throw new ArgumentOutOfRangeException(nameof(commentId));
}
var now = _systemClock.UtcNow.UtcDateTime;
var userCanAddComment = await _permissionsService.UserCanPerformActionAsync(userId, slug, AddCommentRole, cancellationToken);
if (!userCanAddComment)
{
_logger.LogError($"Forbidden: UpdateCommentAsync - User:{0} does not have access to group:{1}", userId, slug);
throw new ForbiddenException($"Forbidden: User does not have access to this group");
}
var userCanEditComment = await _permissionsService.UserCanPerformActionAsync(userId, slug, EditCommentRole, cancellationToken);
var databaseCommentDto = await _commentCommand.GetCommentAsync(commentId, cancellationToken);
if (databaseCommentDto.CreatedById != userId && !userCanEditComment)
{
_logger.LogError($"Forbidden: UpdateCommentAsync - User:{0} does not have permission to edit comment:{1}", userId, commentId);
throw new ForbiddenException("Forbidden: User does not have permission to edit this comment");
}
if (!databaseCommentDto.RowVersion.SequenceEqual(rowVersion))
{
_logger.LogError($"Precondition Failed: UpdateCommentAsync - Comment:{0} has changed prior to submission ", commentId);
throw new PreconditionFailedExeption("Precondition Failed: Comment has changed prior to submission");
}
var commentDto = new CommentDto()
{
EntityId = databaseCommentDto.Id,
Content = comment.Content,
ModifiedBy = userId,
ModifiedAtUTC = now,
};
var validator = new CommentValidator();
var validationResult = await validator.ValidateAsync(commentDto, cancellationToken);
if (validationResult.Errors.Count > 0)
{
throw new ValidationException(validationResult);
}
await _commentCommand.UpdateCommentAsync(commentDto, rowVersion, cancellationToken);
}
/// <summary>
/// Method to validate model
/// </summary>
/// <returns>Returns the result of validation</returns>
protected override FluentValidation.Results.ValidationResult Validate()
{
var validator = new CommentValidator();
return(validator.Validate(this));
}