public void ValidateSensorLogRecordsInvalidInputTest(SensorLogModel sensorLogModel, string expected)
        {
            // Arrange

            // Act
            Action actual = () => _validateSensorRecordRepository.ValidateSensorLogRecords(sensorLogModel);

            // Assert
            using (new AssertionScope())
            {
                actual
                .Should()
                .Throw <ArgumentException>()
                .WithMessage(expected);

                _logger.Invocations.Count
                .Should()
                .Be(1);

                _logger.Invocations[0].Arguments[0]
                .Should()
                .Be(LogLevel.Error);

                _logger
                .Verify(x => x.Log(LogLevel.Error,
                                   It.IsAny <EventId>(),
                                   It.Is <It.IsAnyType>((x, t) => string.Equals(x.ToString(), expected)),
                                   It.IsAny <Exception>(),
                                   It.Is <Func <It.IsAnyType, Exception, string> >((v, t) => true)),
                        Times.Once());
            }
        }
        /// <summary>
        /// Handles the ValidateSensorRecordCommand request
        /// </summary>
        /// <param name="command">ValidateSensorRecordCommand request parameters</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is System.Threading.CancellationToken.None.</param>
        /// <returns>Returns a JSON string validation record wrapped in a CommandResult object</returns>
        public Task <CommandResult <ValidateSensorLogModel> > Handle(ValidateSensorRecordCommand command, CancellationToken cancellationToken = default)
        {
            ValidationResult validation = _validator.Validate(command);

            if (!validation.IsValid)
            {
                _logger.LogError("Validate Sensor Record produced errors: {errors}", validation.ToString());

                CommandResult <ValidateSensorLogModel> invalidCommandResult = new CommandResult <ValidateSensorLogModel>
                {
                    Result            = null,
                    CommandResultType = CommandResultType.InvalidInput
                };

                return(Task.FromResult(invalidCommandResult));
            }

            ValidateSensorLogModel result = _repository.ValidateSensorLogRecords(command.SensorLogModel);

            if (result == null)
            {
                _logger.LogError("Validate Sensor Record produced an invalid result.");

                CommandResult <ValidateSensorLogModel> errorCommandResult = new CommandResult <ValidateSensorLogModel>
                {
                    Result            = null,
                    CommandResultType = CommandResultType.Error
                };

                return(Task.FromResult(errorCommandResult));
            }

            CommandResult <ValidateSensorLogModel> commandResult = new CommandResult <ValidateSensorLogModel>
            {
                Result            = result,
                CommandResultType = CommandResultType.Success
            };

            return(Task.FromResult(commandResult));
        }