< Summary

Information
Class: RoleRadar.Application.Notes.Commands.AppendToNoteCommandValidator
Assembly: RoleRadar.Application
File(s): /home/runner/work/roleradar/roleradar/src/RoleRadar.Application/Notes/Commands/AppendToNoteCommand.cs
Line coverage
78%
Covered lines: 11
Uncovered lines: 3
Coverable lines: 14
Total lines: 105
Line coverage: 78.5%
Branch coverage
62%
Covered branches: 5
Total branches: 8
Branch coverage: 62.5%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
Validate(...)62.5%9878.57%

File(s)

/home/runner/work/roleradar/roleradar/src/RoleRadar.Application/Notes/Commands/AppendToNoteCommand.cs

#LineLine coverage
 1using System.Text;
 2using RoleRadar.Application.Abstractions;
 3using RoleRadar.Domain.Common;
 4using RoleRadar.Domain.Notes;
 5
 6namespace RoleRadar.Application.Notes.Commands;
 7
 8public sealed record NoteUpdatedDto(
 9    Guid Id,
 10    Guid VersionToken,
 11    string BodyHash,
 12    int ByteLength,
 13    DateTime UpdatedAtUtc);
 14
 15public sealed record AppendToNoteCommand(
 16    Guid Id,
 17    string TextToAppend,
 18    string Actor,
 19    string? OwnerId = null) : ICommand<NoteUpdatedDto>;
 20
 21public sealed class AppendToNoteCommandValidator : ICommandValidator<AppendToNoteCommand>
 22{
 23    public ResultError? Validate(AppendToNoteCommand command)
 24    {
 2825        ArgumentNullException.ThrowIfNull(command);
 26
 2827        var actorError = CommandActor.Validate(command.Actor);
 2828        if (actorError is not null)
 29        {
 030            return actorError;
 31        }
 32
 2833        if (command.Id == Guid.Empty)
 34        {
 035            return new ResultError(ErrorCode.ValidationError, "Note ID cannot be Guid.Empty.");
 36        }
 37
 2838        if (string.IsNullOrEmpty(command.TextToAppend))
 39        {
 040            return new ResultError(ErrorCode.ValidationError, "TextToAppend cannot be empty.");
 41        }
 42
 2843        var appendBytes = Encoding.UTF8.GetByteCount(command.TextToAppend);
 2844        if (appendBytes > Note.MaxBodyBytes)
 45        {
 246            return new ResultError(
 247                ErrorCode.ValidationError,
 248                $"TextToAppend UTF-8 size ({appendBytes} bytes) exceeds maximum allowed ({Note.MaxBodyBytes} bytes / 8 M
 49        }
 50
 2651        return null;
 52    }
 53}
 54
 55public sealed class AppendToNoteCommandHandler : ICommandHandler<AppendToNoteCommand, NoteUpdatedDto>
 56{
 57    private static readonly AppendToNoteCommandValidator Validator = new();
 58    private readonly INoteRepository _repository;
 59    private readonly IUtcClock _clock;
 60
 61    public AppendToNoteCommandHandler(INoteRepository repository, IUtcClock clock)
 62    {
 63        ArgumentNullException.ThrowIfNull(repository);
 64        ArgumentNullException.ThrowIfNull(clock);
 65        _repository = repository;
 66        _clock = clock;
 67    }
 68
 69    public async Task<Result<NoteUpdatedDto>> HandleAsync(
 70        AppendToNoteCommand command,
 71        CancellationToken cancellationToken = default)
 72    {
 73        ArgumentNullException.ThrowIfNull(command);
 74
 75        var validationError = Validator.Validate(command);
 76        if (validationError is not null)
 77        {
 78            return Result<NoteUpdatedDto>.Failure(validationError.Value);
 79        }
 80
 81        var ownerId = string.IsNullOrWhiteSpace(command.OwnerId)
 82            ? OwnerId.Default.Value
 83            : new OwnerId(command.OwnerId).Value;
 84
 85        var actor = command.Actor.Trim();
 86        var now = _clock.UtcNow;
 87
 88        var outcome = await _repository.ExecuteInTransactionAsync(
 89            (tx, ct) => tx.AppendAsync(ownerId, command.Id, command.TextToAppend, actor, now, ct),
 90            cancellationToken);
 91
 92        if (!outcome.IsSuccess)
 93        {
 94            return Result<NoteUpdatedDto>.Failure(outcome.Error!.Value);
 95        }
 96
 97        var updated = outcome.Value!.Note;
 98        return Result<NoteUpdatedDto>.Success(new NoteUpdatedDto(
 99            Id: updated.Id,
 100            VersionToken: updated.VersionToken,
 101            BodyHash: updated.CurrentBodyHash,
 102            ByteLength: Encoding.UTF8.GetByteCount(updated.Body),
 103            UpdatedAtUtc: updated.UpdatedAtUtc));
 104    }
 105}