alt/apps/client/test/integrations/socket/alt_socket_client_test.dart

import 'dart:async';
import 'dart:io';
import 'package:flutter_test/flutter_test.dart';
import 'package:proto_socket/proto_socket.dart';

import 'package:alt_client/src/generated/alt/v1/common.pb.dart';
import 'package:alt_client/src/integrations/socket/alt_socket_client.dart';
import 'package:alt_client/src/integrations/socket/socket_endpoint.dart';

class FakeWebSocket extends Stream<dynamic> implements WebSocket {
  final StreamController<dynamic> _controller = StreamController<dynamic>();
  final List<List<int>> sentBytes = [];
  bool isClosed = false;

  @override
  void add(dynamic data) {
    if (data is List<int>) {
      sentBytes.add(data);
    }
  }

  @override
  Future<void> close([int? code, String? reason]) async {
    isClosed = true;
    await _controller.close();
  }

  void feedFromServer(List<int> data) {
    _controller.add(data);
  }

  @override
  StreamSubscription<dynamic> listen(
    void Function(dynamic event)? onData, {
    Function? onError,
    void Function()? onDone,
    bool? cancelOnError,
  }) {
    return _controller.stream.listen(
      onData,
      onError: onError,
      onDone: onDone,
      cancelOnError: cancelOnError,
    );
  }

  @override
  dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
}

void main() {
  group('AltSocketEndpoint tests', () {
    test('default constructor values', () {
      const endpoint = AltSocketEndpoint();
      expect(endpoint.host, equals('127.0.0.1'));
      expect(endpoint.port, equals(8080));
      expect(endpoint.path, equals('/socket'));
      expect(endpoint.toString(), equals('ws://127.0.0.1:8080/socket'));
    });

    test('custom values', () {
      const endpoint = AltSocketEndpoint(
        host: 'api.example.com',
        port: 443,
        path: '/ws',
      );
      expect(endpoint.host, equals('api.example.com'));
      expect(endpoint.port, equals(443));
      expect(endpoint.path, equals('/ws'));
      expect(endpoint.toString(), equals('ws://api.example.com:443/ws'));
    });

    test('equality and hashCode', () {
      const e1 = AltSocketEndpoint(host: '1.2.3.4', port: 9000, path: '/a');
      const e2 = AltSocketEndpoint(host: '1.2.3.4', port: 9000, path: '/a');
      const e3 = AltSocketEndpoint(host: '1.2.3.4', port: 9000, path: '/b');

      expect(e1, equals(e2));
      expect(e1.hashCode, equals(e2.hashCode));
      expect(e1, isNot(equals(e3)));
    });
  });

  group('AltSocketClient tests', () {
    late FakeWebSocket fakeWs;
    late AltSocketClient client;

    setUp(() {
      fakeWs = FakeWebSocket();
      client = AltSocketClient(
        fakeWs,
        heartbeatIntervalTime: 1,
        heartbeatWaitTime: 1,
      );
    });

    tearDown(() async {
      await client.close();
    });

    test('client initialization and parser registration', () {
      expect(client.isAlive, isTrue);

      final helloRequestType =
          HelloRequest.getDefault().info_.qualifiedMessageName;
      final helloResponseType =
          HelloResponse.getDefault().info_.qualifiedMessageName;

      expect(client.getGenerator<HelloRequest>(helloRequestType), isNotNull);
      expect(client.getGenerator<HelloResponse>(helloResponseType), isNotNull);
    });

    test('hello handshake request-response loop', () async {
      final helloFuture = client.hello(timeout: const Duration(seconds: 1));

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

      expect(fakeWs.sentBytes, isNotEmpty);
      final firstSentPacketBytes = fakeWs.sentBytes.first;
      final sentPacket = PacketBase.fromBuffer(firstSentPacketBytes);

      final helloRequestType =
          HelloRequest.getDefault().info_.qualifiedMessageName;
      expect(sentPacket.typeName, equals(helloRequestType));

      final sentHelloRequest = HelloRequest.fromBuffer(sentPacket.data);
      expect(sentHelloRequest.clientName, equals('alt-client'));
      expect(sentHelloRequest.clientVersion, equals('dev'));
      expect(sentHelloRequest.altProtocolVersion, equals('alt.v1'));

      final expectedResponse = HelloResponse()
        ..serverName = 'alt-server'
        ..serverVersion = '1.0.0'
        ..altProtocolVersion = 'alt.v1';

      final responsePacket = PacketBase()
        ..typeName = HelloResponse.getDefault().info_.qualifiedMessageName
        ..nonce = 100
        ..responseNonce = sentPacket.nonce
        ..data = expectedResponse.writeToBuffer();

      fakeWs.feedFromServer(responsePacket.writeToBuffer());

      final response = await helloFuture;

      expect(response.serverName, equals('alt-server'));
      expect(response.serverVersion, equals('1.0.0'));
      expect(response.altProtocolVersion, equals('alt.v1'));
    });
  });
}