How to unit test a SUT that depends on Dispatcher Timer

Question

I have been searching for a solution for 3 days. I've got this one article but unfortunately, it uses a library that's no longer available (https://www.codeproject.com/Articles/19597/How-to-Test-a-Class-Which-Uses-DispatcherTimer). So I'm asking in hope for a new solution, or more elegant way to unit test a class that uses a DispatcherTimer.

Here's the code of my SUT:

    public class RemainingTimeChangedEventArgs : EventArgs
{
    public TimeSpan RemainingTime { get; init; }
    public TimeSpan TimerSetFor { get; init; }
}

public class ExtendedTimer
{
    public event EventHandler<RemainingTimeChangedEventArgs>? RemainingTimeChanged;
    private readonly DispatcherTimer _timer;
    private TimeSpan _timerSetFor  = TimeSpan.Zero;
    private TimeSpan _remainingTime  = TimeSpan.Zero;
    
    public TimeSpan Interval
    {
        get => _timer.Interval;
        set => _timer.Interval = value;
    }
    
    public ExtendedTimer()
    {
        _timer = new();
        _timer.Tick += OnTimeChanged;
        _timer.Interval = TimeSpan.FromSeconds(1);
    }

    public void Initialize(TimeSpan timerSetFor)
    {
        _timerSetFor = timerSetFor;
        _remainingTime = timerSetFor;
    }

    public void Start()
    {
        _timer.Start();
    }

    public void Resume()
    {
        _timer.Start();
    }

    public void Pause()
    {
        _timer.Stop();
    }
    public void Stop()
    {
        _timer.Stop();
    }

    private void OnTimeChanged(object? sender, EventArgs e)
    {
        _remainingTime -= Interval;

        if (_remainingTime == TimeSpan.Zero) _timer.Stop();

        RemainingTimeChanged?.Invoke(this, new RemainingTimeChangedEventArgs
        {
            RemainingTime = _remainingTime,
            TimerSetFor = _timerSetFor
        });
    }
    
    ~ExtendedTimer() {
        _timer.Tick -= OnTimeChanged;
    }

So when the user starts the timer and TimerSetFor is initialized for a given time, it'll raise an event to tell the remaining time every tick/interval elapsed. Once the remaining time reaches 0, it'll raise the event and stop the ticking.

Currently, this is my xUnit test. I use Task.Delay, it's failed, because delaying the task means delaying the Dispatcher Timer to execute as well? But I hope it reveals my intention:

public class ExtendedTimerTests
{
    private readonly ExtendedTimer _sut = new();

    [Theory]
    [InlineData(10, 100, 10)]
    [InlineData(5, 50, 5)]
    [InlineData(20, 30, 1)]
    public async Task Start_GiveCorrectRemainingTimeEveryIntervalElapsed(
        int interval, int timerSetFor, int expectedExecutedFor)
    {
        _sut.Interval = TimeSpan.FromMilliseconds(interval);

        var ticksCount = 0;

        void OnSutOnRemainingTimeChanged(object? sender, RemainingTimeChangedEventArgs args)
        {
            ticksCount++;
        }

        _sut.RemainingTimeChanged += OnSutOnRemainingTimeChanged;

        _sut.Initialize(TimeSpan.FromMilliseconds(timerSetFor));
         _sut.Start();

         await Task.Delay(TimeSpan.FromMilliseconds(timerSetFor));
         Assert.Equal(expectedExecutedFor, ticksCount);


         // make sure the ticksCount still the same even after we wait for another time
         await Task.Delay(TimeSpan.FromMilliseconds(50));
         Assert.Equal(expectedExecutedFor, ticksCount);
    }

}

maybe this helps https://stackoverflow.com/questions/38083711/how-can-i-test-a-class-that-uses-dispatchertimer — DonMiguelSanchez, May 04 '23 at 07:48

score 0 · Answer 1 · answered May 04 '23 at 08:24

The article you posted is telling you the problem:

Threads that run unit tests do not have an active Dispatcher by default

You could change your SUT (ExtendedTimer class) by injecting a Timer Implementation and don't use a DispatcherTimer in your Unit Tests...

Ihsan Nurul Iman · Answer 2 · 2023-05-04T16:31:16.770

I ended up unit testing without bounding to time, and make the DispatcherTimer as a dependency that can be injected.

 public interface ITimer
{
    event EventHandler Tick;
    TimeSpan Interval { get; set; }
    void Start();
    void Stop();
}

 public class DispatcherTimerAdapter : ITimer
{
    private readonly DispatcherTimer _timer = new();

    public event EventHandler? Tick
    {
        add => _timer.Tick += value;
        remove => _timer.Tick -= value;
    }

    public TimeSpan Interval
    {
        get => _timer.Interval;
        set => _timer.Interval = value;
    }

    public void Start()
    {
        _timer.Start();
    }

    public void Stop()
    {
        _timer.Stop();
    }
}

public class ExtendedTimer
{
...
  public ExtendedTimer(ITimer timer) // will be injected with DispatcherTimerAdapter
    {
        _timer = timer;
        _timer.Tick += OnTimeChanged;
        _timer.Interval = TimeSpan.FromSeconds(1);
    }
...
}

The tests:

    public class ExtendedTimerTests
{
    private readonly AutoMocker _mocker = new AutoMocker();
    private readonly Mock<ITimer> _timerMock;
    private readonly ExtendedTimer _sut;

    public ExtendedTimerTests()
    {
        _timerMock = _mocker.GetMock<ITimer>();
        _sut = _mocker.CreateInstance<ExtendedTimer>();
    }

    [Theory]
    [InlineData(1, 10, 10)]
    [InlineData(1, 5, 5)]
    [InlineData(2, 30, 15)]
    public void StartUntilTimerFinishItself_InvokedCorrectlyAndStopAutomatically(
        int intervalInSeconds, int timerSetForInSeconds, int expectedInvokedCount)
    {
        // Arrange
        GenerateTimerSetup(intervalInSeconds, timerSetForInSeconds);

        // Act
        int invokedCount = 0;
        int remainingTimeInSeconds = timerSetForInSeconds;

        _sut.RemainingTimeChanged += (sender, args) =>
        {
            invokedCount++;
            remainingTimeInSeconds = (int)args.RemainingTime.TotalSeconds;
        };

        _sut.Initialize(TimeSpan.FromSeconds(timerSetForInSeconds));
        _sut.Interval = TimeSpan.FromSeconds(intervalInSeconds);
        _sut.Start();

        // Assert
        _timerMock.Verify((x) => x.Stop(), Times.Once);
        Assert.Equal(0, remainingTimeInSeconds);
        Assert.Equal(expectedInvokedCount, invokedCount);
    }

    [Theory]
    [InlineData(1, 10, 5, 5, 5)]
    [InlineData(1, 5, 4, 4, 1)]
    [InlineData(2, 30, 10, 5, 20)]
    public void StartAndCaptureResultHalfway_InvokedCorrectly(
        int intervalInSeconds, 
        int timerSetForInSeconds, 
        int stopAt, 
        int expectedInvokedCount,
        int expectedRemainingTimeInSeconds
        )
    {
        // Arrange
        GenerateTimerSetup(intervalInSeconds, stopAt);

        // Act
        int invokedCount = 0;
        int remainingTimeInSeconds = timerSetForInSeconds;

        _sut.RemainingTimeChanged += (sender, args) =>
        {
            invokedCount++;
            remainingTimeInSeconds = (int)args.RemainingTime.TotalSeconds;
        };

        _sut.Initialize(TimeSpan.FromSeconds(timerSetForInSeconds));
        _sut.Interval = TimeSpan.FromSeconds(intervalInSeconds);
        _sut.Start();

        // Assert
        _timerMock.Verify((x) => x.Stop(), Times.Never);
        Assert.Equal(expectedRemainingTimeInSeconds, remainingTimeInSeconds);
        Assert.Equal(expectedInvokedCount, invokedCount);
    }

    #region Helpers

    private void GenerateTimerSetup(int intervalInSeconds, int stopAt)
    {
        _timerMock.Setup((x) => x.Start())
            .Callback(() =>
            {
                for (int i = 0; i < stopAt; i += intervalInSeconds)
                {
                    _timerMock.Raise((x) =>
                        x.Tick += null, _timerMock.Object, EventArgs.Empty);
                }
            });

        _timerMock.SetupGet((x) => x.Interval)
            .Returns(TimeSpan.FromSeconds(intervalInSeconds));

        _timerMock.Setup((x) => x.Stop());
    }

    #endregion

}

How to unit test a SUT that depends on Dispatcher Timer

2 Answers2