Как вы можете проверить метод с конкретным параметром NSpecification в модульных тестах C #? - PullRequest
Новая
       31

Как вы можете проверить метод с конкретным параметром NSpecification в модульных тестах C #?

2 голосов
/ 15 октября 2019

Я сейчас пишу юнит-тесты для CommandHandler. Я использую Moq 4.12.0 и xUnit 2.4.1 для тестов. Я хотел проверить, вызывается ли этот метод с определенной NSpecification .

Я довольно новичок в мире модульного тестирования.

Это CommandHandler: 

public class DeleteAlarmCodesCommandHandler : IRequestHandler<DeleteAlarmCodesCommand, CommandResult<IEnumerable<AlarmCode>>>
    {
        private readonly Domain.Model.IAlarmCodeRepository _alarmCodeRepository;

        public DeleteAlarmCodesCommandHandler(
            Domain.Model.IAlarmCodeRepository alarmCodeRepository)
        {
            _alarmCodeRepository = alarmCodeRepository;
        }

        public async Task<CommandResult<IEnumerable<AlarmCode>>> Handle(DeleteAlarmCodesCommand request, CancellationToken cancellationToken)
        {            
            ASpec<Domain.Model.AlarmCode> spec = Spec<Domain.Model.AlarmCode>.Any;

            if (request.AlarmId != null)
            {
                spec &= Domain.Model.AlarmCodeSpecifications.ForAlarmId(request.AlarmId);
            }

            if (request.LanguageISO != null)
            {
                spec &= Domain.Model.AlarmCodeSpecifications.ForLanguageISO(request.LanguageISO);
            }

            try
            {
                var alarmCodes = await _alarmCodeRepository.DeleteAsync(spec);
                await _alarmCodeRepository.SaveAsync();

                return new CommandResult<IEnumerable<AlarmCode>>(alarmCodes.Select(x => x.ToViewModel()));
            }
            catch (Domain.ApiDomainException ex)
            {
                return new CommandResult<IEnumerable<AlarmCode>>(ApiErrors.FromException(ex));
            }
        }
    }

И это мой модульный тест, чтобы проверить, есть ли DeleteAsync () вызывается со спецификацией. 

[Fact]
public async Task Should_DeleteWithAlarmIdOne_WhenCalledWitParameterAlarmIdOne()
{
    // Arrange
    var repo = new Mock<IAlarmCodeRepository>();
    var command = new DeleteAlarmCodesCommand() { AlarmId = 1 };

    var commandHandler = new DeleteAlarmCodesCommandHandler(repo.Object);

    // Act
    var result = await commandHandler.Handle(command, It.IsAny<CancellationToken>());

    var spec = Spec<AlarmCode>.Any & AlarmCodeSpecifications.ForAlarmId(command.AlarmId);

   // Assert            
   repo.Verify(x => x.DeleteAsync(spec), Times.Once);
   repo.Verify(x => x.SaveAsync(), Times.Once);
}

Проблема в том, что ссылки на оба объекта различны, так как они создаются, когда они необходимы. Так что Мок видит их как совершенно разные объекты. Потому что, когда я запускаю тест, я получаю следующий результат в области результатов. 

   Duration: 182 ms

  Message: 
    Moq.MockException : 
    Expected invocation on the mock once, but was 0 times: x => x.DeleteAsync(x => (True AndAlso (Convert(Convert(x.AlarmId, Int32), Nullable`1) == Convert(value(Services.Domain.Model.AlarmCodeSpecifications+<>c__DisplayClass0_0).alarmId, Nullable`1))))

    Performed invocations:

       Mock<IAlarmCodeRepository:1> (x):

          IAlarmCodeRepository.DeleteAsync(x => (True AndAlso (Convert(Convert(x.AlarmId, Int32), Nullable`1) == Convert(value(Services.Domain.Model.AlarmCodeSpecifications+<>c__DisplayClass0_0).alarmId, Nullable`1))))
          IRepository`1.SaveAsync()

  Stack Trace: 
    Mock.Verify(Mock mock, LambdaExpression expression, Times times, String failMessage)
    Mock`1.Verify[TResult](Expression`1 expression, Func`1 times)
    DeleteAlarmCodesCommandHandler_Handle.Should_DeleteWithAlarmIdOne_WhenCalledWitParameterAlarmIdOne() line 46
    --- End of stack trace from previous location where exception was thrown ---

Есть ли способ с Moq проверять вызовы со сложными объектами, такими как Spec.

ИлиКак я могу проверить это лучше?

Обновление

Это определение IAlarmCodeRepository. 

 public interface IAlarmCodeRepository : IRepository<AlarmCode>
    {
        IUnitOfWork UnitOfWork { get; }

        Task AddAsync(AlarmCode entity);

        Task<AlarmCode> GetOneAsync(int id);

        Task<AlarmCode> GetOneAsync(ASpec<AlarmCode> spec);

        Task<IEnumerable<AlarmCode>> FindAsync(ASpec<AlarmCode> spec);

        Task<bool> Exists(ASpec<AlarmCode> spec);

        Task<IEnumerable<AlarmCode>> DeleteAsync(ASpec<AlarmCode> spec);

        Task<AlarmCode> DeleteOne(int id);

        Task<IEnumerable<short>> GetDistinctAlarmIds();
    }

public interface IRepository<T>
         where T : IAggregateRoot
    {
        Task SaveAsync();
    }

 public async Task SaveAsync()
        {
            await UnitOfWork.CommitAsync();
        }

Этоспецификации AlarmSpecification. 

 public static class AlarmCodeSpecifications
    {
        public static ASpec<AlarmCode> ForAlarmId(short? alarmId)
        {
            return new Spec<AlarmCode>(o => o.AlarmId == alarmId);
        }
    }

Spec и ASpec поступают из библиотеки спецификаций NS для https://github.com/jnicolau/NSpecifications: https://github.com/jnicolau/NSpecifications/blob/master/Nspecifications/ASpec.cs

1 Ответ

1 голос
/ 15 октября 2019

Некоторые предположения должны были быть сделаны из-за отсутствия информации, но последующее должно обеспечить достаточную платформу, чтобы понять, как выполнять тестируемый предмет 

[Fact]
public async Task Should_DeleteWithAlarmIdOne_WhenCalledWitParameterAlarmIdOne() {
    // Arrange
    short? expectedAlarmId = 1;
    var alarmCode = new AlarmCode { AlarmId = expectedAlarmId };
    var alarmCodes = new List<AlarmCode>(alarmCode);

    var repo = new Mock<IAlarmCodeRepository>();
    //fake the desired functionality
    repo.Setup(_ => _.DeleteAsync(It.IsAny<ASpec<AlarmCode>>()))
        .ReturnsAsync((ASpec<AlarmCode> arg) => alarmCodes.Where(arg));
    //allow async flow
    repo.Setup(_ => _.SaveAsync()).ReturnsAsync(Task.CompletedTask); //assuming it it void (Task)

    var command = new DeleteAlarmCodesCommand() { AlarmId = expectedAlarmId };

    var commandHandler = new DeleteAlarmCodesCommandHandler(repo.Object);

    // Act
    var result = await commandHandler.Handle(command, default(CancellationToken));


    // Assert
    var expected = Spec<AlarmCode>.Any & AlarmCodeSpecifications.ForAlarmId(command.AlarmId);
    repo.Verify(x => x.DeleteAsync(It.Is<ASpec<AlarmCode>>(actual => actual == expected)), Times.Once);
    repo.Verify(x => x.SaveAsync(), Times.Once);
}
...