proto-socket/dart/test/communicator_test.dart

import 'package:protobuf/protobuf.dart';
import 'package:test/test.dart';
import 'package:toki_socket/toki_socket.dart';

class _FakeCommunicator extends Communicator {
  final sentPackets = <PacketBase>[];

  _FakeCommunicator() {
    isAlive = true;
    initialize({
      TestData.getDefault().info_.qualifiedMessageName: TestData.fromBuffer,
      HeartBeat.getDefault().info_.qualifiedMessageName: HeartBeat.fromBuffer,
    });
  }

  @override
  Future<void> transmitPacket(PacketBase base) async {
    sentPackets.add(base);
  }

  void closeForTest() {
    isAlive = false;
    cancelPendingRequests();
  }

  @override
  Future<void> send<T extends GeneratedMessage>(T data) async {
    if (isAlive) {
      await queuePacket(PacketBase()
        ..typeName = data.info_.qualifiedMessageName
        ..nonce = ++nonce
        ..data = data.writeToBuffer());
    }
    return Future.value();
  }
}

void main() {
  group('Communicator protocol guards', () {
    test('response typeName mismatch completes sendRequest with error',
        () async {
      final communicator = _FakeCommunicator();
      final future = communicator.sendRequest<TestData, TestData>(
        TestData()
          ..index = 1
          ..message = 'hello',
      );

      await Future<void>.delayed(Duration.zero);
      final requestNonce = communicator.sentPackets.single.nonce;
      communicator.onReceivedData(
        HeartBeat.getDefault().info_.qualifiedMessageName,
        HeartBeat().writeToBuffer(),
        responseNonce: requestNonce,
      );

      await expectLater(
        future,
        throwsA(
          isA<StateError>().having((error) => error.toString(), 'message',
              contains('Response type mismatch')),
        ),
      );
    });

    test('close 후 sendRequest는 StateError로 완료된다', () async {
      final communicator = _FakeCommunicator();
      final future = communicator.sendRequest<TestData, TestData>(
        TestData()..index = 1,
      );

      await Future<void>.delayed(Duration.zero);
      communicator.closeForTest();

      await expectLater(
        future,
        throwsA(
          isA<StateError>().having(
            (error) => error.message,
            'message',
            contains('connection closed'),
          ),
        ),
      );
    });

    test(
        'cannot register addRequestListener for a type already using addListener',
        () {
      final communicator = _FakeCommunicator();

      communicator.addListener<TestData>((_) {});

      expect(
        () => communicator.addRequestListener<TestData, TestData>(
          (req) async => TestData()..index = req.index,
        ),
        throwsA(isA<StateError>()),
      );
    });

    test(
        'cannot register addListener for a type already using addRequestListener',
        () {
      final communicator = _FakeCommunicator();

      communicator.addRequestListener<TestData, TestData>(
        (req) async => TestData()..index = req.index,
      );

      expect(
        () => communicator.addListener<TestData>((_) {}),
        throwsA(isA<StateError>()),
      );
    });
  });
}