public async Task <Unit> Handle(UpdateMaximumSequenceNumberCommand request, CancellationToken cancellationToken)
        {
            ArgumentNullException.ThrowIfNull(request, nameof(request));

            await _sequenceNumberRepository
            .AdvanceSequenceNumberAsync(new SequenceNumber(request.SequenceNumber))
            .ConfigureAwait(false);

            return(Unit.Value);
        }
        public async Task UpdateHandle_SequenceNumber_IsSaved()
        {
            // Arrange
            const long sequenceNumber = 100;

            var repository = new Mock <ISequenceNumberRepository>();
            var target     = new MaximumSequenceNumberCommandHandler(repository.Object);

            // Act
            var command = new UpdateMaximumSequenceNumberCommand(sequenceNumber);
            await target.Handle(command, CancellationToken.None).ConfigureAwait(false);

            // Assert
            repository.Verify(x => x.AdvanceSequenceNumberAsync(It.Is <SequenceNumber>(s => s.Value == sequenceNumber)));
        }
コード例 #3
0
        public async Task UpdateMaximumSequenceNumberCommand_InvalidCommand_ThrowsException()
        {
            // Arrange
            await using var host = await MarketOperatorIntegrationTestHost
                                   .InitializeAsync()
                                   .ConfigureAwait(false);

            await using var scope = host.BeginScope();
            var mediator = scope.GetInstance <IMediator>();

            var command = new UpdateMaximumSequenceNumberCommand(-10);

            // Act + Assert
            await Assert
            .ThrowsAsync <ValidationException>(() => mediator.Send(command))
            .ConfigureAwait(false);
        }
コード例 #4
0
        public async Task UpdateMaximumSequenceNumberCommand_WithNewNumber_CanReadNumberBack()
        {
            // Arrange
            const long sequenceNumber = int.MaxValue + 1L;

            await using var host = await MarketOperatorIntegrationTestHost
                                   .InitializeAsync()
                                   .ConfigureAwait(false);

            await using var scope = host.BeginScope();
            var mediator = scope.GetInstance <IMediator>();

            var command = new UpdateMaximumSequenceNumberCommand(sequenceNumber);

            // Act
            await mediator.Send(command).ConfigureAwait(false);

            // Assert
            var sequenceNumberRepository = scope.GetInstance <ISequenceNumberRepository>();
            var actual = await sequenceNumberRepository.GetMaximumSequenceNumberAsync().ConfigureAwait(false);

            Assert.Equal(sequenceNumber, actual.Value);
        }
        public async Task Validate_SequenceNumber_ValidatesProperty(long value, bool isValid)
        {
            // Arrange
            const string propertyName = nameof(UpdateMaximumSequenceNumberCommand.SequenceNumber);

            var target  = new UpdateMaximumSequenceNumberCommandRuleSet();
            var command = new UpdateMaximumSequenceNumberCommand(value);

            // Act
            var result = await target.ValidateAsync(command).ConfigureAwait(false);

            // Assert
            if (isValid)
            {
                Assert.True(result.IsValid);
                Assert.DoesNotContain(propertyName, result.Errors.Select(x => x.PropertyName));
            }
            else
            {
                Assert.False(result.IsValid);
                Assert.Contains(propertyName, result.Errors.Select(x => x.PropertyName));
            }
        }