PatrolBinding constructor

Implementation

PatrolBinding(PlatformAutomator platform)
  : _serviceExtensions = DevtoolsServiceExtensions(platform) {
  setUp(() {
    if (_isDevelopMode) {
      return;
    }

    if (global_state.currentTestIndividualName == 'patrol_test_explorer') {
      return;
    }

    _currentDartTest = global_state.currentTestFullName;
  });

  tearDown(() async {
    if (_isDevelopMode) {
      // Sending results ends the test, which we don't want for Hot Restart
      return;
    }

    final testName = global_state.currentTestIndividualName;
    if (testName == 'patrol_test_explorer') {
      return;
    } else {
      logger(
        'tearDown(): count: ${_testResults.length}, results: $_testResults',
      );
    }

    final nameOfRequestedTest = await patrolAppService.testExecutionRequested;

    if (nameOfRequestedTest == _currentDartTest) {
      if (const bool.fromEnvironment('COVERAGE_ENABLED')) {
        try {
          try {
            final serviceInfo = await Service.getInfo();
            final serverUri = serviceInfo.serverUri;
            if (serverUri != null) {
              final infoFile = io.File('/tmp/patrol_vm_service.json');
              await infoFile.writeAsString(
                jsonEncode({'uri': serverUri.toString()}),
              );
              logger('Wrote VM service URI to ${infoFile.path}');
            }
          } catch (e) {
            logger('VM service info file write skipped: $e');
          }

          final testCompleter = Completer<void>();

          registerExtension('ext.patrol.coverageReady', (
            method,
            parameters,
          ) async {
            return ServiceExtensionResponse.result(jsonEncode({
              'mainIsolateId': Service.getIsolateId(Isolate.current),
            }));
          });

          registerExtension('ext.patrol.markTestCompleted', (
            method,
            parameters,
          ) async {
            testCompleter.complete();
            return ServiceExtensionResponse.result(jsonEncode({}));
          });

          await testCompleter.future.timeout(
            const Duration(seconds: 10),
            onTimeout: () {
              logger(
                'Coverage collection timed out after 10s — '
                'CoverageTool may not be connected. Proceeding.',
              );
            },
          );
        } catch (e) {
          logger('Coverage protocol unavailable (web?): $e');
        }
      }

      logger(
        'finished test $_currentDartTest. Will report its status back to the native side',
      );

      final passed = global_state.isCurrentTestPassing;
      logger(
        'tearDown(): test "$testName" in group "$_currentDartTest", passed: $passed',
      );

      await patrolAppService.markDartTestAsCompleted(
        dartFileName: _currentDartTest!,
        passed: passed,
        details: _testResults[_currentDartTest!] is Failure
            ? (_testResults[_currentDartTest!] as Failure?)?.details
            : null,
      );
    } else {
      logger(
        'finished test $_currentDartTest, but it was not requested, so its status will not be reported back to the native side',
      );
    }
  });
}