parse static method

TestReport parse(
  1. List<Event> events, {
  2. String json = '',
})

Implementation

static TestReport parse(List<Event> events, {String json = ''}) {
  final suites = <int, TestSuiteUnit>{};
  final groups = <int, TestGroupUnit>{};
  final tests = <int, TestCaseUnit>{};
  final testStartTimes = <int, int>{};
  final testErrors = <int, Map<String, String?>>{};
  int totalTime = 0;
  bool overallSuccess = true;

  for (final event in events) {
    if (event is SuiteEvent) {
      suites[event.suite.id] = TestSuiteUnit(
        id: event.suite.id,
        path: event.suite.path ?? '',
        platform: event.suite.platform,
        groups: [],
        tests: [],
        isLoadFailure: false, // filled in later
        loadErrorMessage: null, // filled in later
      );
    } else if (event is GroupEvent) {
      groups[event.group.id] = TestGroupUnit(
        id: event.group.id,
        name: _getBaseGroupName(event.group, groups),
        parentID: event.group.parentID,
        tests: [],
      );
    } else if (event is TestStartEvent) {
      testStartTimes[event.test.id] = event.time;
      tests[event.test.id] = TestCaseUnit(
        id: event.test.id,
        name: event.test.name,
        suiteID: event.test.suiteID,
        groupIDs: event.test.groupIDs,
        duration: Duration.zero, // filled in later
        skipped: event.test.metadata.skip,
        success: false, // filled in later
        hidden: false, // filled in later
      );
    } else if (event is ErrorEvent) {
      testErrors[event.testID] = {
        'error': event.error,
        'stack': event.stackTrace,
      };
    } else if (event is TestDoneEvent) {
      final test = tests[event.testID];
      if (test != null) {
        final startTime = testStartTimes[event.testID] ?? 0;
        final duration = Duration(milliseconds: event.time - startTime);
        final err = testErrors[event.testID];

        final updatedTest = TestCaseUnit(
          id: test.id,
          name: _getBaseTestName(test, groups),
          suiteID: test.suiteID,
          groupIDs: test.groupIDs,
          duration: duration,
          skipped: event.skipped,
          success: event.result == 'success',
          hidden: event.hidden,
          error: err?['error'],
          stackTrace: err?['stack'],
        );

        tests[event.testID] = updatedTest;
        suites[test.suiteID]?.tests.add(updatedTest);

        final int? lastGroupId = updatedTest.groupIDs.lastOrNull;
        if (lastGroupId != null) {
          groups[lastGroupId]?.tests.add(updatedTest);
        }

        // for (final groupId in test.groupIDs) {
        //   groups[groupId]?.tests.add(updatedTest);
        // }

        totalTime = event.time;
        if (event.result != 'success') overallSuccess = false;
      }
    } else if (event is DoneEvent) {
      overallSuccess = event.success ?? false;
    }
  }

  _applyTweaks(suites, groups, tests);

  // attach groups to their suites
  for (final group in groups.values) {
    final suiteID = tests.values
        .firstWhereOrNull((t) => t.groupIDs.contains(group.id))
        ?.suiteID;
    if (suiteID != null) {
      suites[suiteID]?.groups.add(group);
    }
  }

  return TestReport(
    json: json,
    suites: suites.values.toList(),
    success: overallSuccess,
    totalDuration: totalTime,
    totalTests: tests.length,
    totalPasses: tests.values.where((t) => t.success).length,
    totalFailures: tests.values.where((t) => !t.success).length,
    totalSkipped: tests.values.where((t) => t.skipped).length,
  );
}