Fix web tests

Author: simolus3

sqlite3_web/lib/src/client.dart

@@ -93,7 +93,7 @@ final class RemoteDatabase implements Database {
   }
 
   @override
-  FileSystem get fileSystem => throw UnimplementedError();
+  late final FileSystem fileSystem = RemoteFileSystem(this);
 
   @override
   Future<int> get lastInsertRowId async {
@@ -391,8 +391,8 @@ final class DatabaseClient implements WebSqlite {
   }
 
   @override
-  Future<Database> connect(
-      String name, StorageMode type, AccessMode access) async {
+  Future<Database> connect(String name, StorageMode type, AccessMode access,
+      {bool onlyOpenVfs = false}) async {
     await startWorkers();
 
     WorkerConnection connection;
@@ -421,6 +421,7 @@ final class DatabaseClient implements WebSqlite {
         wasmUri: wasmUri,
         databaseName: name,
         storageMode: type.resolveToVfs(shared),
+        onlyOpenVfs: onlyOpenVfs,
       ),
       MessageType.simpleSuccessResponse,
     );
@@ -431,7 +432,8 @@ final class DatabaseClient implements WebSqlite {
   }
 
   @override
-  Future<ConnectToRecommendedResult> connectToRecommended(String name) async {
+  Future<ConnectToRecommendedResult> connectToRecommended(String name,
+      {bool onlyOpenVfs = false}) async {
     final probed = await runFeatureDetection(databaseName: name);
 
     // If we have an existing database in storage, we want to keep using that
@@ -460,7 +462,8 @@ final class DatabaseClient implements WebSqlite {
 
     final (storage, access) = availableImplementations.firstOrNull ??
         (StorageMode.inMemory, AccessMode.inCurrentContext);
-    final database = await connect(name, storage, access);
+    final database =
+        await connect(name, storage, access, onlyOpenVfs: onlyOpenVfs);
 
     return ConnectToRecommendedResult(
       database: database,

sqlite3_web/lib/src/database.dart

@@ -162,11 +162,27 @@ abstract class WebSqlite {
 
   /// Connects to a database identified by its [name] stored under [type] and
   /// accessed via the given [access] mode.
-  Future<Database> connect(String name, StorageMode type, AccessMode access);
+  ///
+  /// When [onlyOpenVfs] is enabled, only the underlying file system for the
+  /// database is initialized before [connect] returns. By default, the database
+  /// will also be opened in [connect]. Otherwise, the database will be opened
+  /// on the worker when it's first used.
+  /// Only opening the VFS can be used to, for instance, check if the database
+  /// already exists and to initialize it manually if it doesn't.
+  Future<Database> connect(String name, StorageMode type, AccessMode access,
+      {bool onlyOpenVfs = false});
 
   /// Starts a feature detection via [runFeatureDetection] and then [connect]s
   /// to the best database available.
-  Future<ConnectToRecommendedResult> connectToRecommended(String name);
+  ///
+  /// When [onlyOpenVfs] is enabled, only the underlying file system for the
+  /// database is initialized before [connect] returns. By default, the database
+  /// will also be opened in [connect]. Otherwise, the database will be opened
+  /// on the worker when it's first used.
+  /// Only opening the VFS can be used to, for instance, check if the database
+  /// already exists and to initialize it manually if it doesn't.
+  Future<ConnectToRecommendedResult> connectToRecommended(String name,
+      {bool onlyOpenVfs = false});
 
   /// Entrypoints for workers hosting datbases.
   static void workerEntrypoint({

sqlite3_web/lib/src/protocol.dart

@@ -53,6 +53,7 @@ class _UniqueFieldNames {
   static const id = 'i';
   static const updateKind = 'k';
   static const tableNames = 'n';
+  static const onlyOpenVfs = 'o';
   static const parameters = 'p';
   static const storageMode = 's';
   static const sql = 's'; // not used in same message
@@ -201,12 +202,14 @@ final class OpenRequest extends Request {
 
   final String databaseName;
   final FileSystemImplementation storageMode;
+  final bool onlyOpenVfs;
 
   OpenRequest({
     required super.requestId,
     required this.wasmUri,
     required this.databaseName,
     required this.storageMode,
+    required this.onlyOpenVfs,
   });
 
   factory OpenRequest.deserialize(JSObject object) {
@@ -217,6 +220,9 @@ final class OpenRequest extends Request {
       wasmUri:
           Uri.parse((object[_UniqueFieldNames.wasmUri] as JSString).toDart),
       requestId: object.requestId,
+      onlyOpenVfs:
+          // The onlyOpenVfs field was not set in earlier clients.
+          (object[_UniqueFieldNames.onlyOpenVfs] as JSBoolean?)?.toDart == true,
     );
   }
 
@@ -229,6 +235,7 @@ final class OpenRequest extends Request {
     object[_UniqueFieldNames.databaseName] = databaseName.toJS;
     object[_UniqueFieldNames.storageMode] = storageMode.toJS;
     object[_UniqueFieldNames.wasmUri] = wasmUri.toString().toJS;
+    object[_UniqueFieldNames.onlyOpenVfs] = onlyOpenVfs.toJS;
   }
 }
 

sqlite3_web/lib/src/worker.dart

@@ -182,9 +182,12 @@ final class _ClientConnection extends ProtocolChannel
         try {
           database =
               _runner.findDatabase(request.databaseName, request.storageMode);
-          await database.opened;
+
+          await (request.onlyOpenVfs ? database.vfs : database.opened);
+
           connectionDatabase = _ConnectionDatabase(database);
           _openedDatabases.add(connectionDatabase);
+
           return SimpleSuccessResponse(
               response: database.id.toJS, requestId: request.requestId);
         } catch (e) {
@@ -242,22 +245,20 @@ final class _ClientConnection extends ProtocolChannel
         return SimpleSuccessResponse(
             response: null, requestId: request.requestId);
       case FileSystemFlushRequest():
-        if (database?.database.vfs case IndexedDbFileSystem idb) {
+        if (await database?.database.vfs case IndexedDbFileSystem idb) {
           await idb.flush();
         }
 
         return SimpleSuccessResponse(
             response: null, requestId: request.requestId);
       case FileSystemExistsQuery(:final fsType):
-        await database!.database.opened;
-        final vfs = database.database.vfs!;
+        final vfs = await database!.database.vfs;
         final exists = vfs.xAccess(fsType.pathInVfs, 0) == 1;
 
         return SimpleSuccessResponse(
             response: exists.toJS, requestId: request.requestId);
       case FileSystemAccess(:final buffer, :final fsType):
-        await database!.database.opened;
-        final vfs = database.database.vfs!;
+        final vfs = await database!.database.vfs;
         final file = vfs
             .xOpen(
                 Sqlite3Filename(fsType.pathInVfs), SqlFlag.SQLITE_OPEN_CREATE)
@@ -321,23 +322,23 @@ final class DatabaseState {
   int refCount = 1;
 
   Future<WorkerDatabase>? _database;
+  Future<void>? _openVfs;
+  VirtualFileSystem? _resolvedVfs;
 
   /// Runs additional async work, such as flushing the VFS to IndexedDB when
   /// the database is closed.
   FutureOr<void> Function()? closeHandler;
-  VirtualFileSystem? vfs;
 
   DatabaseState(
       {required this.id,
       required this.runner,
       required this.name,
       required this.mode});
 
-  Future<WorkerDatabase> get opened async {
-    final database = _database ??= Future.sync(() async {
-      final sqlite3 = await runner._sqlite3!;
-      final vfsName = 'vfs-web-$id';
+  String get vfsName => 'vfs-web-$id';
 
+  Future<VirtualFileSystem> get vfs async {
+    await (_openVfs ??= Future.sync(() async {
       switch (mode) {
         case FileSystemImplementation.opfsLocks:
           final options = WasmVfs.createOptions(root: pathForOpfs(name));
@@ -349,22 +350,31 @@ final class DatabaseState {
           await EventStreamProviders.messageEvent.forTarget(worker).first;
 
           final wasmVfs =
-              vfs = WasmVfs(workerOptions: options, vfsName: vfsName);
+              _resolvedVfs = WasmVfs(workerOptions: options, vfsName: vfsName);
           closeHandler = wasmVfs.close;
         case FileSystemImplementation.opfsShared:
-          final simple = vfs = await SimpleOpfsFileSystem.loadFromStorage(
-              pathForOpfs(name),
-              vfsName: vfsName);
+          final simple = _resolvedVfs =
+              await SimpleOpfsFileSystem.loadFromStorage(pathForOpfs(name),
+                  vfsName: vfsName);
           closeHandler = simple.close;
         case FileSystemImplementation.indexedDb:
-          final idb = vfs =
+          final idb = _resolvedVfs =
               await IndexedDbFileSystem.open(dbName: name, vfsName: vfsName);
           closeHandler = idb.close;
         case FileSystemImplementation.inMemory:
-          vfs = InMemoryFileSystem(name: vfsName);
+          _resolvedVfs = InMemoryFileSystem(name: vfsName);
       }
+    }));
+
+    return _resolvedVfs!;
+  }
+
+  Future<WorkerDatabase> get opened async {
+    final database = _database ??= Future.sync(() async {
+      final sqlite3 = await runner._sqlite3!;
+      final fileSystem = await vfs;
 
-      sqlite3.registerVirtualFileSystem(vfs!);
+      sqlite3.registerVirtualFileSystem(fileSystem);
       return await runner._controller.openDatabase(
         sqlite3,
         // We're currently using /database as the in-VFS path. This is because
@@ -391,7 +401,7 @@ final class DatabaseState {
     final database = await _database!;
 
     database.database.dispose();
-    if (vfs case final vfs?) {
+    if (_resolvedVfs case final vfs?) {
       sqlite3.unregisterVirtualFileSystem(vfs);
     }
 

sqlite3_web/test/integration_test.dart

@@ -1,3 +1,4 @@
+import 'dart:async';
 import 'dart:io';
 
 import 'package:sqlite3_web/src/types.dart';
@@ -82,9 +83,24 @@ void main() {
     group(browser.name, () {
       late Process driverProcess;
       late TestWebDriver driver;
+      var isStoppingProcess = false;
+      final processStopped = Completer<void>();
+
+      setUpAll(() async {
+        final process = driverProcess = await browser.spawnDriver();
+        process.exitCode.then((code) {
+          if (!isStoppingProcess) {
+            throw 'Webdriver stopped (code $code) before tearing down tests.';
+          }
 
-      setUpAll(() async => driverProcess = await browser.spawnDriver());
-      tearDownAll(() => driverProcess.kill());
+          processStopped.complete();
+        });
+      });
+      tearDownAll(() {
+        isStoppingProcess = true;
+        driverProcess.kill();
+        return processStopped.future;
+      });
 
       setUp(() async {
         final rawDriver = await createDriver(
@@ -103,9 +119,12 @@ void main() {
           },
         );
 
-        rawDriver.logs.get(LogType.browser).listen((entry) {
-          print('[console]: ${entry.message}');
-        });
+        // logs.get() isn't supported on Firefox
+        if (browser != Browser.firefox) {
+          rawDriver.logs.get(LogType.browser).listen((entry) {
+            print('[console]: ${entry.message}');
+          });
+        }
 
         driver = TestWebDriver(server, rawDriver);
         await driver.driver.get('http://localhost:8080/');
@@ -138,11 +157,18 @@ void main() {
 
       for (final (storage, access) in browser.availableImplementations) {
         test('$storage through $access', () async {
-          await driver.openDatabase((storage, access));
+          await driver.openDatabase(
+            implementation: (storage, access),
+            onlyOpenVfs: true,
+          );
+          await driver.assertFile(false);
+
           await driver.execute('CREATE TABLE foo (bar TEXT);');
           expect(await driver.countUpdateEvents(), 0);
           await driver.execute("INSERT INTO foo (bar) VALUES ('hello');");
           expect(await driver.countUpdateEvents(), 1);
+
+          expect(await driver.assertFile(true), isPositive);
         });
       }
     });

sqlite3_web/tool/server.dart

@@ -136,15 +136,18 @@ class TestWebDriver {
     );
   }
 
-  Future<(StorageMode, AccessMode)> openDatabase(
-      [(StorageMode, AccessMode)? implementation]) async {
+  Future<(StorageMode, AccessMode)> openDatabase({
+    (StorageMode, AccessMode)? implementation,
+    bool onlyOpenVfs = false,
+  }) async {
     final desc = switch (implementation) {
       null => null,
       (var storage, var access) => '${storage.name}:${access.name}'
     };
 
+    final method = onlyOpenVfs ? 'open_only_vfs' : 'open';
     final res = await driver
-        .executeAsync('open(arguments[0], arguments[1])', [desc]) as String?;
+        .executeAsync('$method(arguments[0], arguments[1])', [desc]) as String?;
 
     // This returns the storage/access mode actually chosen.
     final split = res!.split(':');
@@ -175,4 +178,20 @@ class TestWebDriver {
       throw 'test_second failed! More information may be available in the console.';
     }
   }
+
+  Future<int?> assertFile(bool shouldExist) async {
+    final res = await driver.executeAsync(
+        'assert_file(arguments[0], arguments[1])', [shouldExist.toString()]);
+    res!;
+
+    if (res == false) {
+      throw 'assertFile failed! Expected $shouldExist, match return was $res';
+    }
+
+    if (res is int) {
+      return res;
+    } else {
+      return null;
+    }
+  }
 }