pkgs/coverage/test/collect_coverage_mock_test.dart

// Copyright (c) 2022, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

import 'package:coverage/coverage.dart';
import 'package:mockito/annotations.dart';
import 'package:mockito/mockito.dart';
import 'package:test/test.dart';
import 'package:vm_service/vm_service.dart';

import 'collect_coverage_mock_test.mocks.dart';

@GenerateMocks([VmService])
SourceReportRange _range(int scriptIndex, SourceReportCoverage coverage) =>
    SourceReportRange(scriptIndex: scriptIndex, coverage: coverage);

IsolateRef _isoRef(String id, String isoGroupId) =>
    IsolateRef(id: id, isolateGroupId: isoGroupId);

IsolateGroupRef _isoGroupRef(String id) => IsolateGroupRef(id: id);

IsolateGroup _isoGroup(String id, List<IsolateRef> isolates) =>
    IsolateGroup(id: id, isolates: isolates);

class FakeSentinelException implements SentinelException {
  @override
  dynamic noSuchMethod(Invocation invocation) {}
}

MockVmService _mockService(
  int majorVersion,
  int minorVersion, {
  Map<String, List<String>> isolateGroups = const {
    'isolateGroup': ['isolate'],
  },
}) {
  final service = MockVmService();
  final isoRefs = <IsolateRef>[];
  final isoGroupRefs = <IsolateGroupRef>[];
  final isoGroups = <IsolateGroup>[];
  for (final group in isolateGroups.entries) {
    isoGroupRefs.add(_isoGroupRef(group.key));
    final isosOfGroup = <IsolateRef>[];
    for (final isoId in group.value) {
      isosOfGroup.add(_isoRef(isoId, group.key));
    }
    isoGroups.add(_isoGroup(group.key, isosOfGroup));
    isoRefs.addAll(isosOfGroup);
  }
  when(service.getVM()).thenAnswer(
      (_) async => VM(isolates: isoRefs, isolateGroups: isoGroupRefs));
  for (final group in isoGroups) {
    when(service.getIsolateGroup(group.id)).thenAnswer((_) async => group);
  }
  when(service.getVersion()).thenAnswer(
      (_) async => Version(major: majorVersion, minor: minorVersion));
  return service;
}

void main() {
  group('Mock VM Service', () {
    test('Collect coverage', () async {
      final service = _mockService(4, 13);
      when(service.getSourceReport(
        'isolate',
        ['Coverage'],
        forceCompile: true,
        reportLines: true,
      )).thenAnswer((_) async => SourceReport(
            ranges: [
              _range(
                0,
                SourceReportCoverage(
                  hits: [12],
                  misses: [47],
                ),
              ),
              _range(
                1,
                SourceReportCoverage(
                  hits: [95],
                  misses: [52],
                ),
              ),
            ],
            scripts: [
              ScriptRef(
                uri: 'package:foo/foo.dart',
                id: 'foo',
              ),
              ScriptRef(
                uri: 'package:bar/bar.dart',
                id: 'bar',
              ),
            ],
          ));

      final jsonResult = await collect(Uri(), false, false, false, null,
          serviceOverrideForTesting: service);
      final result = await HitMap.parseJson(
          jsonResult['coverage'] as List<Map<String, dynamic>>);

      expect(result.length, 2);
      expect(result['package:foo/foo.dart']?.lineHits, {12: 1, 47: 0});
      expect(result['package:bar/bar.dart']?.lineHits, {95: 1, 52: 0});
    });

    test('Collect coverage, scoped output', () async {
      final service = _mockService(4, 13);
      when(service.getSourceReport(
        'isolate',
        ['Coverage'],
        forceCompile: true,
        reportLines: true,
        libraryFilters: ['package:foo/'],
      )).thenAnswer((_) async => SourceReport(
            ranges: [
              _range(
                0,
                SourceReportCoverage(
                  hits: [12],
                  misses: [47],
                ),
              ),
            ],
            scripts: [
              ScriptRef(
                uri: 'package:foo/foo.dart',
                id: 'foo',
              ),
            ],
          ));

      final jsonResult = await collect(Uri(), false, false, false, {'foo'},
          serviceOverrideForTesting: service);
      final result = await HitMap.parseJson(
          jsonResult['coverage'] as List<Map<String, dynamic>>);

      expect(result.length, 1);
      expect(result['package:foo/foo.dart']?.lineHits, {12: 1, 47: 0});
    });

    test('Collect coverage, fast isolate group deduping', () async {
      final service = _mockService(4, 13, isolateGroups: {
        'isolateGroupA': ['isolate1', 'isolate2'],
        'isolateGroupB': ['isolate3'],
      });
      when(service.getSourceReport(
        'isolate1',
        ['Coverage'],
        forceCompile: true,
        reportLines: true,
      )).thenAnswer((_) async => SourceReport(
            ranges: [
              _range(
                0,
                SourceReportCoverage(
                  hits: [12],
                  misses: [47],
                ),
              ),
              _range(
                1,
                SourceReportCoverage(
                  hits: [95],
                  misses: [52],
                ),
              ),
            ],
            scripts: [
              ScriptRef(
                uri: 'package:foo/foo.dart',
                id: 'foo',
              ),
              ScriptRef(
                uri: 'package:bar/bar.dart',
                id: 'bar',
              ),
            ],
          ));
      when(service.getSourceReport(
        'isolate3',
        ['Coverage'],
        forceCompile: true,
        reportLines: true,
      )).thenAnswer((_) async => SourceReport(
            ranges: [
              _range(
                0,
                SourceReportCoverage(
                  hits: [34],
                  misses: [61],
                ),
              ),
            ],
            scripts: [
              ScriptRef(
                uri: 'package:baz/baz.dart',
                id: 'baz',
              ),
            ],
          ));

      final jsonResult = await collect(Uri(), false, false, false, null,
          serviceOverrideForTesting: service);
      final result = await HitMap.parseJson(
          jsonResult['coverage'] as List<Map<String, dynamic>>);

      expect(result.length, 3);
      expect(result['package:foo/foo.dart']?.lineHits, {12: 1, 47: 0});
      expect(result['package:bar/bar.dart']?.lineHits, {95: 1, 52: 0});
      expect(result['package:baz/baz.dart']?.lineHits, {34: 1, 61: 0});
      verifyNever(service.getSourceReport('isolate2', ['Coverage'],
          forceCompile: true, reportLines: true));
      verifyNever(service.getIsolateGroup('isolateGroupA'));
      verifyNever(service.getIsolateGroup('isolateGroupB'));
    });

    test(
        'Collect coverage, no scoped output, '
        'handles SentinelException from getSourceReport', () async {
      final service = _mockService(4, 13);
      when(service.getSourceReport(
        'isolate',
        ['Coverage'],
        forceCompile: true,
        reportLines: true,
      )).thenThrow(FakeSentinelException());

      final jsonResult = await collect(Uri(), false, false, false, null,
          serviceOverrideForTesting: service);
      final result = await HitMap.parseJson(
          jsonResult['coverage'] as List<Map<String, dynamic>>);

      expect(result.length, 0);
    });

    test('Collect coverage, coverableLineCache', () async {
      // Expect that on the first getSourceReport call, librariesAlreadyCompiled
      // is empty.
      final service = _mockService(4, 13);
      when(service.getSourceReport(
        'isolate',
        ['Coverage'],
        forceCompile: true,
        reportLines: true,
        librariesAlreadyCompiled: [],
      )).thenAnswer((_) async => SourceReport(
            ranges: [
              _range(
                0,
                SourceReportCoverage(
                  hits: [12],
                  misses: [47],
                ),
              ),
              _range(
                1,
                SourceReportCoverage(
                  hits: [95],
                  misses: [52],
                ),
              ),
            ],
            scripts: [
              ScriptRef(
                uri: 'package:foo/foo.dart',
                id: 'foo',
              ),
              ScriptRef(
                uri: 'package:bar/bar.dart',
                id: 'bar',
              ),
            ],
          ));

      final coverableLineCache = <String, Set<int>>{};
      final jsonResult = await collect(Uri(), false, false, false, null,
          coverableLineCache: coverableLineCache,
          serviceOverrideForTesting: service);
      final result = await HitMap.parseJson(
          jsonResult['coverage'] as List<Map<String, dynamic>>);

      expect(result.length, 2);
      expect(result['package:foo/foo.dart']?.lineHits, {12: 1, 47: 0});
      expect(result['package:bar/bar.dart']?.lineHits, {95: 1, 52: 0});

      // The coverableLineCache should now be filled with all the lines that
      // were hit or missed.
      expect(coverableLineCache, {
        'package:foo/foo.dart': {12, 47},
        'package:bar/bar.dart': {95, 52},
      });

      // The second getSourceReport call should now list all the libraries we've
      // seen. The response won't contain any misses for these libraries,
      // because they won't be force compiled. We'll also return a 3rd library,
      // which will contain misses, as it hasn't been compiled yet.
      when(service.getSourceReport(
        'isolate',
        ['Coverage'],
        forceCompile: true,
        reportLines: true,
        librariesAlreadyCompiled: [
          'package:foo/foo.dart',
          'package:bar/bar.dart'
        ],
      )).thenAnswer((_) async => SourceReport(
            ranges: [
              _range(
                0,
                SourceReportCoverage(
                  hits: [47],
                ),
              ),
              _range(
                1,
                SourceReportCoverage(
                  hits: [95],
                ),
              ),
              _range(
                2,
                SourceReportCoverage(
                  hits: [36],
                  misses: [81],
                ),
              ),
            ],
            scripts: [
              ScriptRef(
                uri: 'package:foo/foo.dart',
                id: 'foo',
              ),
              ScriptRef(
                uri: 'package:bar/bar.dart',
                id: 'bar',
              ),
              ScriptRef(
                uri: 'package:baz/baz.dart',
                id: 'baz',
              ),
            ],
          ));

      final jsonResult2 = await collect(Uri(), false, false, false, null,
          coverableLineCache: coverableLineCache,
          serviceOverrideForTesting: service);
      final result2 = await HitMap.parseJson(
          jsonResult2['coverage'] as List<Map<String, dynamic>>);

      // The missed lines still appear in foo and bar, even though they weren't
      // returned in the response. They were read from the cache.
      expect(result2.length, 3);
      expect(result2['package:foo/foo.dart']?.lineHits, {12: 0, 47: 1});
      expect(result2['package:bar/bar.dart']?.lineHits, {95: 1, 52: 0});
      expect(result2['package:baz/baz.dart']?.lineHits, {36: 1, 81: 0});

      // The coverableLineCache should now also contain the baz library.
      expect(coverableLineCache, {
        'package:foo/foo.dart': {12, 47},
        'package:bar/bar.dart': {95, 52},
        'package:baz/baz.dart': {36, 81},
      });
    });

    test(
        'Collect coverage, scoped output, '
        'handles SourceReports that contain unfiltered ranges', () async {
      // Regression test for https://github.com/dart-lang/tools/issues/530
      final service = _mockService(4, 13);
      when(service.getSourceReport(
        'isolate',
        ['Coverage'],
        forceCompile: true,
        reportLines: true,
        libraryFilters: ['package:foo/'],
      )).thenAnswer((_) async => SourceReport(
            ranges: [
              _range(
                0,
                SourceReportCoverage(
                  hits: [12],
                  misses: [47],
                ),
              ),
              _range(
                1,
                SourceReportCoverage(
                  hits: [86],
                  misses: [91],
                ),
              ),
            ],
            scripts: [
              ScriptRef(
                uri: 'package:foo/foo.dart',
                id: 'foo',
              ),
              ScriptRef(
                uri: 'package:bar/bar.dart',
                id: 'bar',
              ),
            ],
          ));

      final jsonResult = await collect(Uri(), false, false, false, {'foo'},
          serviceOverrideForTesting: service);
      final result = await HitMap.parseJson(
          jsonResult['coverage'] as List<Map<String, dynamic>>);

      expect(result.length, 1);
      expect(result['package:foo/foo.dart']?.lineHits, {12: 1, 47: 0});
    });
  });
}