Add metadata test

Author: srujzs

dwds/lib/src/debugging/inspector.dart

@@ -114,7 +114,7 @@ class AppInspector implements AppInspectorInterface {
 
     // TODO(srujzs): We can invalidate these in a smarter way instead of
     // reinitializing when doing a hot reload, but these helpers recompute info
-    // on demand and therefore are not in the critical path.
+    // on demand later and therefore are not in the critical path.
     _classHelper = ClassHelper(this);
     _instanceHelper = InstanceHelper(this);
 
@@ -729,7 +729,7 @@ class AppInspector implements AppInspectorInterface {
   /// This will get repopulated on restarts and reloads.
   ///
   /// If [invalidatedModuleReport] is provided, only invalidates and
-  /// recalculates caches for the invalidated libraries.
+  /// recalculates caches for the invalidated/new libraries.
   ///
   /// Returns the list of scripts refs cached.
   Future<List<ScriptRef>> _populateScriptCaches([
@@ -740,10 +740,13 @@ class AppInspector implements AppInspectorInterface {
           await globalToolConfiguration.loadStrategy
               .metadataProviderFor(appConnection.request.entrypointPath)
               .scripts;
-      final invalidatedLibraries = invalidatedModuleReport?.deletedLibraries
+      final invalidatedAndNewLibraries = invalidatedModuleReport
+          ?.deletedLibraries
           .union(invalidatedModuleReport.reloadedLibraries);
-      if (invalidatedLibraries != null) {
-        for (final libraryUri in invalidatedLibraries) {
+      if (invalidatedAndNewLibraries != null) {
+        // Invalidate any script caches that were computed for the now invalid
+        // libraries. They will get repopulated later.
+        for (final libraryUri in invalidatedAndNewLibraries) {
           final libraryRef = await _libraryHelper.libraryRefFor(libraryUri);
           final libraryId = libraryRef?.id;
           if (libraryId == null) continue;
@@ -768,8 +771,8 @@ class AppInspector implements AppInspectorInterface {
         isolate.libraries ?? <LibraryRef>[],
       );
       for (final uri in userLibraries) {
-        if (invalidatedLibraries != null &&
-            !invalidatedLibraries.contains(uri)) {
+        if (invalidatedAndNewLibraries != null &&
+            !invalidatedAndNewLibraries.contains(uri)) {
           continue;
         }
         final parts = scripts[uri];

dwds/lib/src/debugging/metadata/provider.dart

@@ -170,6 +170,12 @@ class MetadataProvider {
     return _moduleToModulePath.keys.toList();
   }
 
+  /// Compute metadata information after reading the metadata contents.
+  ///
+  /// If [hotReload] is true, skips adding the SDK metadata and caches the
+  /// computed [ModuleMetadata], returning the resulting cache.
+  ///
+  /// Otherwise, adds all metadata and returns null.
   Future<Map<String, ModuleMetadata>?> _processMetadata(bool hotReload) async {
     final modules = hotReload ? <String, ModuleMetadata>{} : null;
     // The merged metadata resides next to the entrypoint.
@@ -211,10 +217,17 @@ class MetadataProvider {
     return modules;
   }
 
+  /// Process all metadata and compute caches once.
   Future<void> _initialize() async {
     await _metadataMemoizer.runOnce(() => _processMetadata(false));
   }
 
+  /// Given a map of hot reloaded modules mapped to their respective libraries,
+  /// determines deleted and invalidated libraries and modules, invalidates them
+  /// in any caches, and recomputes the necessary information.
+  ///
+  /// Returns an [InvalidatedModuleReport] that can be used to invalidate other
+  /// caches after a hot reload.
   Future<InvalidatedModuleReport> reinitializeAfterReload(
     Map<String, List> reloadedModulesToLibraries,
   ) async {
@@ -318,12 +331,23 @@ class AbsoluteImportUriException implements Exception {
   String toString() => "AbsoluteImportUriError: '$importUri'";
 }
 
+/// Computed after a hot reload using
+/// [MetadataProvider.reinitializeAfterReload], represents the modules and
+/// libraries in the program that were deleted, reloaded, and therefore,
+/// invalidated.
+///
+/// Used to recompute caches throughout DWDS.
 class InvalidatedModuleReport {
+  /// Module names that are no longer in the program.
   final Set<String> deletedModules;
+
+  /// Library uris that are no longer in the program.
   final Set<String> deletedLibraries;
-  // The union of invalidated and new modules.
+
+  /// Module names that were loaded during the hot reload.
   final Set<String> reloadedModules;
-  // The union of invalidated and new libraries.
+
+  /// Library uris that were loaded during the hot reload.
   final Set<String> reloadedLibraries;
   InvalidatedModuleReport({
     required this.deletedModules,

dwds/test/fixtures/fakes.dart

@@ -414,12 +414,11 @@ class FakeStrategy extends LoadStrategy {
 }
 
 class FakeAssetReader implements AssetReader {
-  final String? _metadata;
+  String? metadata;
   final String? _dartSource;
   final String? _sourceMap;
-  const FakeAssetReader({metadata, dartSource, sourceMap})
-    : _metadata = metadata,
-      _dartSource = dartSource,
+  FakeAssetReader({this.metadata, dartSource, sourceMap})
+    : _dartSource = dartSource,
       _sourceMap = sourceMap;
 
   @override
@@ -432,7 +431,7 @@ class FakeAssetReader implements AssetReader {
 
   @override
   Future<String> metadataContents(String serverPath) {
-    return _throwUnimplementedOrReturnContents(_metadata);
+    return _throwUnimplementedOrReturnContents(metadata);
   }
 
   @override

dwds/test/fixtures/utilities.dart

@@ -196,9 +196,7 @@ class TestToolConfiguration extends ToolConfiguration {
     TestDebugSettings super.debugSettings =
         const TestDebugSettings.noDevTools(),
     TestBuildSettings buildSettings = const TestBuildSettings.dart(),
-  }) : super(
-         loadStrategy: TestStrategy(const FakeAssetReader(), buildSettings),
-       );
+  }) : super(loadStrategy: TestStrategy(FakeAssetReader(), buildSettings));
 
   TestToolConfiguration.withLoadStrategy({
     TestAppMetadata super.appMetadata = const TestAppMetadata.externalApp(),

dwds/test/metadata_test.dart

@@ -5,6 +5,8 @@
 @Timeout(Duration(minutes: 2))
 library;
 
+import 'dart:convert';
+
 import 'package:dwds/src/debugging/metadata/module_metadata.dart';
 import 'package:dwds/src/debugging/metadata/provider.dart';
 import 'package:test/test.dart';
@@ -115,4 +117,151 @@ void main() {
       expect(parts[0], 'org-dartlang-app:///web/main.dart');
     }
   });
+
+  String createMetadataContents(
+    Map<String, List<String>> moduleToLibraries,
+    Map<String, List<String>> libraryToParts,
+  ) {
+    final contents = StringBuffer('');
+    for (final module in moduleToLibraries.keys) {
+      final moduleMetadata = ModuleMetadata(
+        module,
+        'load__web__$module',
+        'foo/web/$module.ddc.js.map',
+        'foo/web/$module.ddc.js',
+      );
+      for (final library in moduleToLibraries[module]!) {
+        moduleMetadata.addLibrary(
+          LibraryMetadata(library, library, libraryToParts[library] ?? []),
+        );
+      }
+      contents.writeln(json.encode(moduleMetadata.toJson()));
+    }
+    contents.write('// intentionally empty: ...');
+    return contents.toString();
+  }
+
+  Future<void> verifyExpectations(
+    MetadataProvider provider,
+    Map<String, List<String>> moduleToLibraries,
+    Map<String, List<String>> libraryToParts,
+  ) async {
+    final scriptToModule = await provider.scriptToModule;
+    final expectedScriptToModule = <String, String>{};
+    for (final module in moduleToLibraries.keys) {
+      final libraries = moduleToLibraries[module]!;
+      for (final library in libraries) {
+        expectedScriptToModule[library] = module;
+        final parts = libraryToParts[library];
+        if (parts != null) {
+          for (final part in parts) {
+            expectedScriptToModule[part] = module;
+          }
+        }
+      }
+    }
+    for (final entry in expectedScriptToModule.entries) {
+      expect(scriptToModule[entry.key], entry.value);
+    }
+
+    final moduleToSourceMap = await provider.moduleToSourceMap;
+    final expectedModuleToSourceMap = moduleToLibraries.keys.fold(
+      <String, String>{},
+      (map, module) {
+        map[module] = 'foo/web/$module.ddc.js.map';
+        return map;
+      },
+    );
+    for (final entry in expectedModuleToSourceMap.entries) {
+      expect(moduleToSourceMap[entry.key], entry.value);
+    }
+
+    final modulePathToModule = await provider.modulePathToModule;
+    final expectedModulePathToModule = moduleToLibraries.keys.fold(
+      <String, String>{},
+      (map, module) {
+        map['foo/web/$module.ddc.js'] = module;
+        return map;
+      },
+    );
+    for (final entry in expectedModulePathToModule.entries) {
+      expect(modulePathToModule[entry.key], entry.value);
+    }
+
+    expect(await provider.modules, containsAll(moduleToLibraries.keys));
+  }
+
+  test('reinitialize produces correct report', () async {
+    final moduleToLibraries = <String, List<String>>{
+      'm1': [
+        'org-dartlang-app:///web/l1.dart',
+        'org-dartlang-app:///web/l2.dart',
+      ],
+      'm2': [
+        'org-dartlang-app:///web/l3.dart',
+        'org-dartlang-app:///web/l4.dart',
+      ],
+      'm3': [
+        'org-dartlang-app:///web/l5.dart',
+        'org-dartlang-app:///web/l6.dart',
+      ],
+    };
+    final libraryToParts = <String, List<String>>{
+      'l1': ['org-dartlang-app:///web/l1_p1.dart'],
+    };
+    final assetReader = FakeAssetReader(
+      metadata: createMetadataContents(moduleToLibraries, libraryToParts),
+    );
+    final provider = MetadataProvider('foo.bootstrap.js', assetReader);
+    await verifyExpectations(provider, moduleToLibraries, libraryToParts);
+
+    final newModuleToLibraries = <String, List<String>>{
+      'm1': [
+        'org-dartlang-app:///web/l1.dart',
+        'org-dartlang-app:///web/l2.dart',
+      ],
+      'm3': ['org-dartlang-app:///web/l3.dart'],
+      'm4': [
+        'org-dartlang-app:///web/l4.dart',
+        'org-dartlang-app:///web/l7.dart',
+      ],
+    };
+    final newLibraryToParts = <String, List<String>>{
+      'l1': ['org-dartlang-app:///web/l1_p1.dart'],
+      'l7': ['org-dartlang-app:///web/l7_p1.dart'],
+    };
+    final reloadedModulesToLibraries = <String, List<String>>{
+      'm3': ['org-dartlang-app:///web/l3.dart'],
+      'm4': [
+        'org-dartlang-app:///web/l4.dart',
+        'org-dartlang-app:///web/l7.dart',
+      ],
+    };
+    assetReader.metadata = createMetadataContents(
+      newModuleToLibraries,
+      newLibraryToParts,
+    );
+    final invalidatedModuleReport = await provider.reinitializeAfterReload(
+      reloadedModulesToLibraries,
+    );
+    expect(invalidatedModuleReport.deletedModules, ['m2']);
+    expect(invalidatedModuleReport.deletedLibraries, [
+      'org-dartlang-app:///web/l5.dart',
+      'org-dartlang-app:///web/l6.dart',
+    ]);
+    expect(
+      invalidatedModuleReport.reloadedModules,
+      reloadedModulesToLibraries.keys,
+    );
+    expect(
+      invalidatedModuleReport.reloadedLibraries,
+      containsAll(
+        reloadedModulesToLibraries.values.fold<List<String>>([], (value, l) {
+          value.addAll(l);
+          return l;
+        }),
+      ),
+    );
+    await verifyExpectations(provider, newModuleToLibraries, newLibraryToParts);
+  });
 }