client_test.dart

// Copyright 2013 The Flutter Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

import 'dart:async';
import 'dart:io';

import 'package:multicast_dns/multicast_dns.dart';
import 'package:test/fake.dart';
import 'package:test/test.dart';

void main() {
  test('Can inject datagram socket factory and configure mdns port', () async {
    late int lastPort;
    final datagramSocket = FakeRawDatagramSocket();
    final client = MDnsClient(
      rawDatagramSocketFactory:
          (
            dynamic host,
            int port, {
            bool reuseAddress = true,
            bool reusePort = true,
            int ttl = 1,
          }) async {
            lastPort = port;
            return datagramSocket;
          },
    );

    await client.start(
      mDnsPort: 1234,
      interfacesFactory: (InternetAddressType type) async =>
          <NetworkInterface>[],
    );

    expect(lastPort, 1234);
  });

  test('Closes IPv4 sockets', () async {
    final datagramSocket = FakeRawDatagramSocket();
    final client = MDnsClient(
      rawDatagramSocketFactory:
          (
            dynamic host,
            int port, {
            bool reuseAddress = true,
            bool reusePort = true,
            int ttl = 1,
          }) async {
            return datagramSocket;
          },
    );

    await client.start(
      mDnsPort: 1234,
      interfacesFactory: (InternetAddressType type) async =>
          <NetworkInterface>[],
    );
    expect(datagramSocket.closed, false);
    client.stop();
    expect(datagramSocket.closed, true);
  });

  test('Closes IPv6 sockets', () async {
    final datagramSocket = FakeRawDatagramSocket();
    datagramSocket.address = InternetAddress.anyIPv6;
    final client = MDnsClient(
      rawDatagramSocketFactory:
          (
            dynamic host,
            int port, {
            bool reuseAddress = true,
            bool reusePort = true,
            int ttl = 1,
          }) async {
            return datagramSocket;
          },
    );

    await client.start(
      mDnsPort: 1234,
      interfacesFactory: (InternetAddressType type) async =>
          <NetworkInterface>[],
    );
    expect(datagramSocket.closed, false);
    client.stop();
    expect(datagramSocket.closed, true);
  });

  test('start() is idempotent', () async {
    final datagramSocket = FakeRawDatagramSocket();
    datagramSocket.address = InternetAddress.anyIPv4;
    final client = MDnsClient(
      rawDatagramSocketFactory:
          (
            dynamic host,
            int port, {
            bool reuseAddress = true,
            bool reusePort = true,
            int ttl = 1,
          }) async {
            return datagramSocket;
          },
    );

    await client.start(
      interfacesFactory: (InternetAddressType type) async =>
          <NetworkInterface>[],
    );
    await client.start();
    await client.lookup(ResourceRecordQuery.serverPointer('_')).toList();
  });

  group('Bind a single socket to ANY IPv4 and more than one when IPv6', () {
    final testCases = <Map<String, Object>>[
      <String, Object>{
        'name': 'IPv4',
        'datagramSocketType': InternetAddress.anyIPv4,
        'interfacePrefix': '192.168.2.',
      },
      <String, Object>{
        'name': 'IPv6',
        'datagramSocketType': InternetAddress.anyIPv6,
        'interfacePrefix': '2001:0db8:85a3:0000:0000:8a2e:7335:030',
      },
    ];

    for (final testCase in testCases) {
      test('Bind a single socket to ANY ${testCase["name"]}', () async {
        final datagramSocket = FakeRawDatagramSocket();

        datagramSocket.address =
            testCase['datagramSocketType']! as InternetAddress;

        final selectedInterfacesForSendingPackets = <dynamic>[];
        final client = MDnsClient(
          rawDatagramSocketFactory:
              (
                dynamic host,
                int port, {
                bool reuseAddress = true,
                bool reusePort = true,
                int ttl = 1,
              }) async {
                selectedInterfacesForSendingPackets.add(host);
                return datagramSocket;
              },
        );

        const numberOfFakeInterfaces = 10;
        Future<Iterable<NetworkInterface>> fakeNetworkInterfacesFactory(
          InternetAddressType type,
        ) async {
          final fakeInterfaces = <NetworkInterface>[];

          // Generate "fake" interfaces
          for (var i = 0; i < numberOfFakeInterfaces; i++) {
            fakeInterfaces.add(
              FakeNetworkInterface('inetfake$i', <InternetAddress>[
                InternetAddress("${testCase['interfacePrefix']! as String}$i"),
              ], 0),
            );
          }

          // ignore: always_specify_types
          return Future.value(fakeInterfaces);
        }

        final listenAddress =
            testCase['datagramSocketType']! as InternetAddress;

        await client.start(
          listenAddress: listenAddress,
          mDnsPort: 1234,
          interfacesFactory: fakeNetworkInterfacesFactory,
        );
        client.stop();

        if (testCase['datagramSocketType'] == InternetAddress.anyIPv4) {
          expect(selectedInterfacesForSendingPackets.length, 1);
        } else {
          // + 1 because of unspecified address (::)
          expect(
            selectedInterfacesForSendingPackets.length,
            numberOfFakeInterfaces + 1,
          );
        }
        expect(selectedInterfacesForSendingPackets[0], listenAddress.address);
      });
    }
  });

  test('Calls onError callback in case of socket error', () async {
    final datagramSocket = FakeRawDatagramSocketThatSendsError();
    final client = MDnsClient(
      rawDatagramSocketFactory:
          (
            dynamic host,
            int port, {
            bool reuseAddress = true,
            bool reusePort = true,
            int ttl = 1,
          }) async {
            return datagramSocket;
          },
    );

    final onErrorCalledCompleter = Completer<void>();
    await client.start(
      mDnsPort: 1234,
      interfacesFactory: (InternetAddressType type) async =>
          <NetworkInterface>[],
      onError: (Object e) {
        expect(e, 'Error');
        onErrorCalledCompleter.complete();
      },
    );

    await onErrorCalledCompleter.future.timeout(const Duration(seconds: 5));
  });
}

class FakeRawDatagramSocket extends Fake implements RawDatagramSocket {
  @override
  InternetAddress address = InternetAddress.anyIPv4;

  @override
  StreamSubscription<RawSocketEvent> listen(
    void Function(RawSocketEvent event)? onData, {
    Function? onError,
    void Function()? onDone,
    bool? cancelOnError,
  }) {
    return const Stream<RawSocketEvent>.empty().listen(
      onData,
      onError: onError,
      cancelOnError: cancelOnError,
      onDone: onDone,
    );
  }

  bool closed = false;

  @override
  void close() {
    closed = true;
  }

  @override
  int send(List<int> buffer, InternetAddress address, int port) {
    return buffer.length;
  }

  @override
  void joinMulticast(InternetAddress group, [NetworkInterface? interface]) {
    // nothing to do here
  }
  @override
  void setRawOption(RawSocketOption option) {
    // nothing to do here
  }
}

class FakeRawDatagramSocketThatSendsError extends Fake
    implements RawDatagramSocket {
  @override
  InternetAddress address = InternetAddress.anyIPv4;

  @override
  StreamSubscription<RawSocketEvent> listen(
    void Function(RawSocketEvent event)? onData, {
    Function? onError,
    void Function()? onDone,
    bool? cancelOnError,
  }) {
    return Stream<RawSocketEvent>.error('Error').listen(
      onData,
      onError: onError,
      cancelOnError: cancelOnError,
      onDone: onDone,
    );
  }
}

class FakeNetworkInterface implements NetworkInterface {
  FakeNetworkInterface(this._name, this._addresses, this._index);

  final String _name;
  final List<InternetAddress> _addresses;
  final int _index;

  @override
  List<InternetAddress> get addresses => _addresses;

  @override
  String get name => _name;

  @override
  int get index => _index;
}