Assert all the items emitted by a Stream in order until it is canceled in Dart?

Question

Is there any convenient way to assert all the items emitted by a Stream in order until it is canceled?

If I use:

expectLater(
  stream,
  emitsInOrder(<String>[
    'item1',
    'item2',
  ]),
);

and the Stream emits ['item1', 'item2', 'item3'] , the test won't fail.

The only way I've found so far is the following:

var count = 0;
final expected = ['item1', 'item2', 'item3'];
stream.listen(
  expectAsync1(
    (final result) {
      expect(result, expected[count++]);
    },
    count: expected.length,
  ),
);

But it is a bit verbose and not very easy to read. Is there a simpler/more elegant way?

Answer 1

emitsDone can be used if the Stream is closed at some point.

E.g:

test('Test', () async {
  final controller = StreamController<String>();
  final stream = controller.stream;
  final matcher = expectLater(
    stream,
    emitsInOrder(<dynamic>[
      'Item1',
      'Item2',
      emitsDone,
    ]),
  );
  controller
    ..add('Item1')
    ..add('Item2')
    ..add('Item3')
    ..close();
  await matcher;
  await controller.close();
});

The test fails with error:

Expected: should do the following in order:
          • emit an event that 'Item1'
          • emit an event that 'Item2'
          • be done
  Actual: <Instance of '_ControllerStream<String>'>
   Which: emitted • Item1
                  • Item2
                  • Item3
                  x Stream closed.
            which didn't be done

As @Irn suggest, a more compact alternative for Streams that complete at some point is using toList:

test('Test', () async {
  final controller = StreamController<String>();
  final stream = controller.stream;
  final matcher = expectLater(stream.toList(), completion(<String>['Item1', 'Item2']));
  controller
    ..add('Item1')
    ..add('Item2')
    ..add('Item3')
    ..close();
  await matcher;
  await controller.close();
});

If the Stream is never closed, you can add a timeout and check the items that have been emitted in that period:

test('Test3', () async {
  final controller = StreamController<String>();
  final stream = controller.stream.timeout(const Duration(milliseconds: 200));
  final matcher = expectLater(
    stream,
    emitsInOrder(<dynamic>[
      'Item1',
      'Item2',
    ]),
  );
  controller
    ..add('Item1')
    ..add('Item2');
  await matcher;
  await controller.close();
});

Answer 2

You can collect the items into a list, using toList, then compare it to your own expectation list:

await expectLater(stream.toList(), completion(expected));

This does not handle the case where the stream doesn't close at all (but then, nothing does, you just have to wait for a timeout).

It doesn't catch errors until all events have been emitted, the emitsInOrder approach is better for that. Not shorter, though.