Testing task delay

Question

Not sure how to achieve this. I'm trying to unit test a method which waits a few minutes, see here:

internal class JctRestartViaSmsAttemptTestRunner : ITestRunner<JctRestartViaSmsAttempt>
{
    private readonly IMayWantMonitoring _queues;
    private readonly IAppSettings _appSettings;

    public JctRestartViaSmsAttemptTestRunner(IMayWantMonitoring queues, IAppSettings appSettings)
    {
        _queues = queues;
        _appSettings = appSettings;
    }

    public JctTest Execute(JctRestartViaSmsAttempt jctMessageType)
    {
        // after five minutes, publish an event to check if the JCT logged in
        var jctLoggedInTimeOut = TimeSpan.FromMinutes(double.Parse(_appSettings["JctLogInTimeOut"]));
        var message = new JctRestartViaSmsValidate(jctMessageType.Imei);

        Task.Delay(jctLoggedInTimeOut)
            .ContinueWith(x => _queues.Publish(message));

        // reset test values
        return new JctTest("6", jctMessageType.Imei, null, null, null);
    }
}

This is my test method but I can't manage to mock the task delay stuff.

    [Test]
    public void TaskTest()
    {
        // arrange
        var imei = _fixture.Create<string>();
        _appSettings.Setup(c => c["JctLogInTimeOut"]).Returns("5");
        var message = _fixture.Build<JctRestartViaSmsAttempt>()
            .With(x => x.Imei, imei)
            .Create();

        var sut = _fixture.Create<JctRestartViaSmsAttemptTestRunner>();

        // act
        sut.Execute(message);

        // assert
        _queues.Verify(x => x.Publish(It.Is<JctRestartViaSmsValidate>(y => y.Imei == imei)));
    }

This is the error raised:

Moq.MockException : Expected invocation on the mock at least once, but was never performed: x => x.Publish(It.Is(y => y.Imei == .imei)) No setups configured. No invocations performed. at Moq.Mock.ThrowVerifyException(MethodCall expected, IEnumerable1 setups, IEnumerable1 actualCalls, Expression expression, Times times, Int32 callCount) at Moq.Mock.VerifyCalls(Interceptor targetInterceptor, MethodCall expected, Expression expression, Times times) at Moq.Mock.Verify[T](Mock1 mock, Expression1 expression, Times times, String failMessage) at Moq.Mock1.Verify(Expression1 expression) at JustEat.PrivateAPN.Worker.UnitTests.TestRunners.JctRestartViaSmsAttemptTestFixture.RunJctTest_WhenRestartAttemptSmsIsSent_ShouldPublishJctRestartValidateMessageWithTheRightImei() in

I know I need to customize/configure my fixture in order to get into the callback but I'm not sure how to do it, any help would be very appreciated

Answer 1

You shouldn't be firing a Task off without awaiting for it to finish when your test and other things may rely on the result.

So I suggest you change to:

internal class JctRestartViaSmsAttemptTestRunner : ITestRunner<JctRestartViaSmsAttempt>
{
    private readonly IMayWantMonitoring _queues;
    private readonly IAppSettings _appSettings;

    public JctRestartViaSmsAttemptTestRunner(IMayWantMonitoring queues, IAppSettings appSettings)
    {
        _queues = queues;
        _appSettings = appSettings;
    }

    public async Task<JctTest> ExecuteAsync(JctRestartViaSmsAttempt jctMessageType)
    {
        // after five minutes, publish an event to check if the JCT logged in
        var jctLoggedInTimeOut = TimeSpan.FromMinutes(double.Parse(_appSettings["JctLogInTimeOut"]));
        var message = new JctRestartViaSmsValidate(jctMessageType.Imei);

        // this will now delay in a non blocking fashion.
        await Task.Delay(jctLoggedInTimeOut);

        _queues.Publish(message);

        // reset test values
        return new JctTest("6", jctMessageType.Imei, null, null, null);
    }
}

Another reason for awaiting is that you have this _queues if you intend to read from that later on, you can never guarantee the contents because there may still be a thread in the threadpool processing the Task.Delay.

Alternative

If you can't change the signature of the method then you will have to go with the Thread.Sleep() which will block the current thread until it has finished.

Because you did specify Task.Delay I would assume you are using it for the benefits of non blocking.

If you were to use Thread.Sleep() you may want to consider running the JctRestartViaSmsAttemptTestRunner in a Task.Run() so that is will only block the thread it is running on.

internal class JctRestartViaSmsAttemptTestRunner : ITestRunner<JctRestartViaSmsAttempt>
{
    private readonly IMayWantMonitoring _queues;
    private readonly IAppSettings _appSettings;

    public JctRestartViaSmsAttemptTestRunner(IMayWantMonitoring queues, IAppSettings appSettings)
    {
        _queues = queues;
        _appSettings = appSettings;
    }

    public JctTest Execute(JctRestartViaSmsAttempt jctMessageType)
    {
        // after five minutes, publish an event to check if the JCT logged in
        var jctLoggedInTimeOut = TimeSpan.FromMinutes(double.Parse(_appSettings["JctLogInTimeOut"]));
        var message = new JctRestartViaSmsValidate(jctMessageType.Imei);

        Thread.Wait(jctLoggedInTimeOut.Milliseconds);

        _queues.Publish(message);

        // reset test values
        return new JctTest("6", jctMessageType.Imei, null, null, null);
    }
}

Tests

If you have a method that does return Task<> then you will have to use .Result if you can't have async test method signatures. Which shouldn't be an issue if you run all your tests in serial. If you don't know why .Result and .Wait() are bad read here

So for your async version:

JctTest test = runner.ExecuteAsync().Result;

And your non async version stays the same.

Answer 2

The execute method is not realy testable, because it starts a delayed task, but you are not able to manage that task from outside.

So, you could try to work with Thread.Sleep which is not nice but should work:

[Test]
public void TaskTest()
{
    // arrange
    var imei = _fixture.Create<string>();
    _appSettings.Setup(c => c["JctLogInTimeOut"]).Returns("1");
    var message = _fixture.Build<JctRestartViaSmsAttempt>()
        .With(x => x.Imei, imei)
        .Create();

    var sut = _fixture.Create<JctRestartViaSmsAttemptTestRunner>();

    // act
    sut.Execute(message);

    // verify the task was not executed yet
    // ....

    // let the test thread sleep and give the task some time to run
    Thread.Sleep(2000);

    // assert
    _queues.Verify(x => x.Publish(It.Is<JctRestartViaSmsValidate>(y => y.Imei == imei)));
}

Answer 3

I think the problem is the test is allowed to finish. Your creating a new task after the delay to start but the test function itself completes before this.

I am not overly familiar with the testing framework. But I would expect you want to use .Wait() on the end of the task. This will create a blocking task and your main test thread will be blocked until the delay is finished.