Flutter: How can I unit test a Timer used by a Bloc using blocTest?

Question

How can I test a Timer inside a Bloc, using blocTest? I’m using the bloc library, with freezed to build the state and event objects (might not matter here, but who knows).

So let’s say I have something like this in my bloc class:

@override
Stream<MyState> mapEventToState(
    MyEvent event,
    ) {
  return event.when(
    start: (value) async* {
      yield state.copyWith(/* add state data */);
    },
    getStream: _myStream(),
  );
}

Stream<MyState> _myStream() async* {
  MyResult? result;

  try {
    final repo = await _repoProvider();
    result = await repo.fetchResult();
  } on Exception catch (e) {
    _logger.e(e);
    /* do some stuff irrelevant to the example */
  }
  
  Timer(const Duration(minutes: 1), () {
      add(const MyEvent.getStream());

  });

  yield state.copyWith(
  /* fill state object with data*/
  );
}

So if my bloc receives a getStream event, the _myStream() function is called to handle the emitting. This function starts a timer, to submit another getStream event after 1 minute. How can I test this in a unit test without having to wait for a minute (I’m using bloc library’s bloc_test to write blocTest functions for my blocs. This comes with a wait functionality, but it really just waits for the submitted amount of time)? I’ve tried to solve this using FakeAsync, but to no avail - I could always only register the first event. I thought something like this would work, but it doesn’t: blocTest<MyBloc, MyState>( "repo should be called twice", build: () {

    return TravelBloc(
     
      mockRepoProvider,
      mockTrackerProvider,
    );
  },
  act: (bloc) =>
      fakeAsync((async) {
        bloc.add(const MyEvent.getStream());
        async.elapse(Duration(minutes: 1, seconds: 1));
      }),
  expect: () => [
       /* check state here */
      ],
  verify: (_) {
    verify(mockRepo.fetchResult).called(2);
  });

Is there any good solution how to test such a construction properly without actual waiting? fakeAsync seems to be the correct choice but I see myself unable to combine it with blocTest.

Answer 1

As you mentioned wait parameter from the blocTest method should be used for testing the things like timers, debounces, etc. However, in your case, this wouldn't be sufficient, because your unit test(s) become too slow to execute.

You have just to apply the DI principle (by the way, you are already using it when you supply mocks to the BLoC) and provide the Duration object to your TravelBloc's constructor. So your build callback from blocTest will look like this:

blocTest(
...
build: () => TravelBloc(
       mockRepoProvider,
       mockTrackerProvider,
       updateInterval: tUpdateInterval,
),
...
);

This technique is very helpful when you need to "control" something inside your class/method within your test.

Answer 2

I faced a similar use case where I had to delay the execution of code in a couple of places in a bloc but I didn't want those delays to affect unit tests. I implemented Pauser and NonPauser classes, the latter being a no-op that I'd use only in tests.

class Pauser {
  const Pauser();

  Future<void> pause300ms() async {
    await Future.delayed(const Duration(milliseconds: 300));
  }

  Future<void> pause500ms() async {
    await Future.delayed(const Duration(milliseconds: 500));
  }

  Future<void> pause5sec() async {
    await Future.delayed(const Duration(seconds: 5));
  }
}

class NonPauser implements Pauser {
  const NonPauser();

  @override
  Future<void> pause300ms() async {
    // no-op
  }

  @override
  Future<void> pause500ms() async {
    // no-op
  }

  @override
  Future<void> pause5sec() async {
    // no-op
  }
}

I'd then pass the no-op instance in the build callback in my tests:

blocTest<FooCubit, FooState>('given an initial state, when stuff is done, then the correct state is emitted',
        build: () => FooCubit(pauser: const NonPauser()),
        act: (bloc) => bloc.doStuff(),
        expect: () => [FooStateImpl()]
);

The cubit then uses the Pauser like so:

class FooCubit extends Cubit<FooState> {
  FooCubit({Pauser pauser = const Pauser()})
      : _pauser = pauser,
        super(FooEmpty());

  final Pauser _pauser;

  Future<void> doStuff() async {
    await _pauser.pause300ms();
    _handleDo();
  }
}