Fix web tests

Author: simolus3

sqlite3/README.md

@@ -147,7 +147,7 @@ In this directory, run:
 
 ```
 cmake -S assets/wasm -B .dart_tool/sqlite3_build --toolchain toolchain.cmake
-make -C .dart_tool/sqlite3_build/ -j output
+cmake --build .dart_tool/sqlite3_build/ -t output -j
 ```
 
 (Of course, you can also run the build in any other directory).

sqlite3/dart_test.yaml

@@ -12,12 +12,24 @@ override_platforms:
   firefox:
     settings:
       arguments: "-headless"
+  chrome:
+    settings:
+      arguments: "--enable-features=SharedArrayBuffer"
+  edge:
+    settings:
+      arguments: "--enable-features=SharedArrayBuffer"
 
 presets:
   full:
     platforms: [vm, chrome, firefox]
+    on_os:
+      windows:
+        platforms: [vm, chrome, firefox, edge]
   web:
     platforms: [chrome, firefox]
+    on_os:
+      windows:
+        platforms: [chrome, firefox, edge]
   ci:
     tags:
       ci_only:

sqlite3/lib/src/wasm/vfs/async_opfs/client.dart

@@ -80,6 +80,10 @@ class WasmVfs extends BaseVirtualFileSystem {
     _runInWorker(WorkerOperation.xSleep, Flags(duration.inMilliseconds, 0, 0));
   }
 
+  void close() {
+    _runInWorker(WorkerOperation.stopServer, const EmptyMessage());
+  }
+
   static bool get supportsAtomicsAndSharedMemory {
     return Atomics.supported && hasProperty(globalThis, 'SharedArrayBuffer');
   }

sqlite3/lib/src/wasm/vfs/async_opfs/sync_channel.dart

@@ -181,6 +181,10 @@ enum WorkerOperation<Req extends Message, Res extends Message> {
     MessageSerializer.readFlags,
     MessageSerializer.readEmpty,
   ),
+  stopServer<EmptyMessage, EmptyMessage>(
+    MessageSerializer.readEmpty,
+    MessageSerializer.readEmpty,
+  ),
   ;
 
   final Req Function(MessageSerializer) readRequest;

sqlite3/lib/src/wasm/vfs/async_opfs/worker.dart

@@ -65,6 +65,8 @@ class VfsWorker {
   final FileSystemDirectoryHandle root;
 
   var _fdCounter = 0;
+  var _stopped = false;
+
   final Map<int, _OpenedFileHandle> _openFiles = {};
   final Set<_OpenedFileHandle> _implicitlyHeldLocks = {};
 
@@ -277,7 +279,7 @@ class VfsWorker {
   }
 
   Future<void> start() async {
-    while (true) {
+    while (!_stopped) {
       final waitResult = synchronizer.waitForRequest();
       if (waitResult == Atomics.timedOut) {
         // No requests for some time, transition to idle
@@ -335,6 +337,11 @@ class VfsWorker {
           case WorkerOperation.xUnlock:
             response = await _xUnlock(request as Flags);
             break;
+          case WorkerOperation.stopServer:
+            response = const EmptyMessage();
+            _stopped = true;
+            _releaseImplicitLocks();
+            break;
         }
 
         messages.write(response);

sqlite3/lib/src/wasm/wasm_interop.dart

@@ -487,7 +487,7 @@ class _InjectedValues {
       'dart': {
         // See assets/wasm/bridge.h
         'error_log': allowInterop((Pointer ptr) {
-          print('Error reported by native handler: ${memory.readString(ptr)}');
+          print('[sqlite3] ${memory.readString(ptr)}');
         }),
         'xOpen': allowInterop((int vfsId, Pointer zName, Pointer dartFdPtr,
             int flags, Pointer pOutFlags) {

sqlite3/test/wasm/file_system_test.dart

@@ -1,5 +1,6 @@
 @Tags(['wasm'])
 import 'dart:async';
+import 'dart:developer';
 import 'dart:math';
 import 'dart:typed_data';
 
@@ -12,55 +13,15 @@ const _fsRoot = '/test';
 
 Future<void> main() async {
   group('in memory', () {
-    _testWith(() => FileSystem.inMemory());
+    _testWith(() => InMemoryFileSystem());
   });
 
   group('indexed db', () {
     _testWith(() => IndexedDbFileSystem.open(dbName: _randomName()));
 
-    test('with proper persistence', () async {
-      final data = Uint8List.fromList(List.generate(255, (i) => i));
-      final dbName = _randomName();
-
-      await expectLater(IndexedDbFileSystem.databases(),
-          completion(anyOf(isNull, isNot(contains(dbName)))),
-          reason: 'Database $dbName should not exist');
-
-      final db1 = await IndexedDbFileSystem.open(dbName: dbName);
-      expect(db1.files.length, 0, reason: 'db1 is not empty');
-
-      db1.createFile('test');
-      db1.write('test', data, 0);
-      db1.truncateFile('test', 128);
-      await db1.flush();
-      expect(db1.files, ['test'], reason: 'File must exist');
-      await db1.close();
-
-      final db2 = await IndexedDbFileSystem.open(dbName: dbName);
-      expect(db2.files, ['test'], reason: 'Single file must be in db2 as well');
-
-      final read = Uint8List(128);
-      expect(db2.read('test', read, 0), 128, reason: 'Should read 128 bytes');
-      expect(read, List.generate(128, (i) => i),
-          reason: 'The data written and read do not match');
-
-      await db2.clear();
-      expect(db2.files, isEmpty, reason: 'There must be no files in db2');
-
-      await db2.close();
-      await expectLater(
-          Future.sync(db2.clear), throwsA(isA<FileSystemException>()));
-
-      await IndexedDbFileSystem.deleteDatabase(dbName);
-      await expectLater(IndexedDbFileSystem.databases(),
-          completion(anyOf(isNull, isNot(contains(dbName)))),
-          reason: 'Database $dbName should not exist in the end');
-    });
-
     test('example with frequent writes', () async {
       final fileSystem = await IndexedDbFileSystem.open(dbName: 'test');
-      final sqlite3 =
-          await loadSqlite3(SqliteEnvironment(fileSystem: fileSystem));
+      final sqlite3 = await loadSqlite3(fileSystem);
       final database = sqlite3.open('test');
       expect(database.userVersion, 0);
       database.userVersion = 1;
@@ -95,53 +56,26 @@ Future<void> main() async {
       await fileSystem.close().timeout(const Duration(seconds: 1));
 
       final fileSystem2 = await IndexedDbFileSystem.open(dbName: 'test');
-      final sqlite32 =
-          await loadSqlite3(SqliteEnvironment(fileSystem: fileSystem2));
+      final sqlite32 = await loadSqlite3(fileSystem2);
       final database2 = sqlite32.open('test');
       expect(database2.userVersion, 1);
       expect(database2.select('SELECT * FROM users'), hasLength(200));
     });
-
-    test('can delete and re-create files', () async {
-      final dbName = _randomName();
-      final fs = await IndexedDbFileSystem.open(dbName: dbName);
-      addTearDown(() async {
-        await fs.close();
-        return IndexedDbFileSystem.deleteDatabase(dbName);
-      });
-
-      fs.createFile('foo');
-      fs.write('foo', Uint8List.fromList([1, 2, 3]), 0);
-      await fs.flush();
-
-      fs.deleteFile('foo');
-      await fs.flush();
-
-      fs.createFile('foo');
-      fs.write('foo', Uint8List.fromList([4, 5, 6]), 0);
-      await fs.flush();
-
-      final target = Uint8List(3);
-      fs.read('foo', target, 0);
-      expect(target, [4, 5, 6]);
-    });
   });
 }
 
 final _random = Random(DateTime.now().millisecond);
 String _randomName() => _random.nextInt(0x7fffffff).toString();
 
-Future<void> _disposeFileSystem(FileSystem fs, [String? name]) async {
+Future<void> _disposeFileSystem(VirtualFileSystem fs, [String? name]) async {
   if (fs is IndexedDbFileSystem) {
     await fs.close();
     if (name != null) await IndexedDbFileSystem.deleteDatabase(name);
-  } else {
-    await Future.sync(fs.clear);
   }
 }
 
-Future<void> _testWith(FutureOr<FileSystem> Function() open) async {
-  late FileSystem fs;
+Future<void> _testWith(FutureOr<VirtualFileSystem> Function() open) async {
+  late VirtualFileSystem fs;
 
   setUp(() async {
     fs = await open();
@@ -151,55 +85,68 @@ Future<void> _testWith(FutureOr<FileSystem> Function() open) async {
 
   test('can create files', () {
     expect(fs.exists('$_fsRoot/foo.txt'), isFalse);
-    expect(fs.files, isEmpty);
     fs.createFile('$_fsRoot/foo.txt');
     expect(fs.exists('$_fsRoot/foo.txt'), isTrue);
-    expect(fs.files, ['$_fsRoot/foo.txt']);
-    fs.deleteFile('$_fsRoot/foo.txt');
-    expect(fs.files, isEmpty);
+    fs.xDelete('$_fsRoot/foo.txt', 0);
+    expect(fs.exists('$_fsRoot/foo.txt'), isFalse);
   });
 
   test('can create and delete multiple files', () {
+    final paths = <String>[];
+
     for (var i = 1; i <= 10; i++) {
-      fs.createFile('$_fsRoot/foo$i.txt');
+      final path = '$_fsRoot/foo$i.txt';
+      paths.add(path);
+
+      debugger();
+      fs.createFile(path);
+      expect(fs.exists(path), isTrue);
     }
-    expect(fs.files, hasLength(10));
-    for (final f in fs.files) {
-      fs.deleteFile(f);
+
+    for (final path in paths) {
+      fs.xDelete(path, 0);
+      expect(fs.exists(path), isFalse);
     }
-    expect(fs.files, isEmpty);
   });
 
   test('reads and writes', () {
     expect(fs.exists('$_fsRoot/foo.txt'), isFalse);
+
+    final file = fs
+        .xOpen(Sqlite3Filename('$_fsRoot/foo.txt'), SqlFlag.SQLITE_OPEN_CREATE)
+        .file;
+
     fs.createFile('$_fsRoot/foo.txt');
-    addTearDown(() => fs.deleteFile('$_fsRoot/foo.txt'));
+    addTearDown(() {
+      file.xClose();
+      fs.xDelete('$_fsRoot/foo.txt', 0);
+    });
 
-    expect(fs.sizeOfFile('$_fsRoot/foo.txt'), isZero);
+    expect(file.xFileSize(), isZero);
 
-    fs.truncateFile('$_fsRoot/foo.txt', 1024);
-    expect(fs.sizeOfFile('$_fsRoot/foo.txt'), 1024);
+    file.xTruncate(1024);
+    expect(file.xFileSize(), 1024);
 
-    fs.truncateFile('$_fsRoot/foo.txt', 600);
-    expect(fs.sizeOfFile('$_fsRoot/foo.txt'), 600);
+    file.xTruncate(600);
+    expect(file.xFileSize(), 600);
 
-    fs.truncateFile('$_fsRoot/foo.txt', 0);
-    expect(fs.sizeOfFile('$_fsRoot/foo.txt'), 0);
+    file.xTruncate(0);
+    expect(file.xFileSize(), 0);
 
-    fs.write('$_fsRoot/foo.txt', Uint8List.fromList([1, 2, 3]), 0);
-    expect(fs.sizeOfFile('$_fsRoot/foo.txt'), 3);
+    file.xWrite(Uint8List.fromList([1, 2, 3]), 0);
+    expect(file.xFileSize(), 3);
 
     final target = Uint8List(3);
-    expect(fs.read('$_fsRoot/foo.txt', target, 0), 3);
+    file.xRead(target, 0);
     expect(target, [1, 2, 3]);
   });
+}
 
-  test('can create files and clear fs', () async {
-    for (var i = 1; i <= 10; i++) {
-      fs.createFile('$_fsRoot/foo$i.txt');
-    }
-    expect(fs.files, hasLength(10));
-    await Future.sync(fs.clear);
-    expect(fs.files, isEmpty);
-  });
+extension on VirtualFileSystem {
+  bool exists(String file) => xAccess(file, 0) != 0;
+
+  void createFile(String path) {
+    final open = xOpen(Sqlite3Filename(path), SqlFlag.SQLITE_OPEN_CREATE);
+    open.file.xClose();
+  }
 }

sqlite3/test/wasm/sqlite3_test.dart

@@ -77,27 +77,39 @@ void main() {
       });
 
       // See worker.dart for the supported backends
-      for (final backend in ['memory', 'opfs-simple', 'indexeddb']) {
-        test(backend, () async {
-          final worker = Worker(workerUri);
-
-          worker.onError.listen((event) {
-            if (event is ErrorEvent) {
-              fail('Error ${event.message} - ${event.error}');
-            } else {
-              fail(event.toString());
+      for (final backend in ['memory', 'opfs-simple', 'opfs', 'indexeddb']) {
+        final requiresSab = backend == 'opfs';
+
+        test(
+          backend,
+          () async {
+            final worker = Worker(workerUri);
+
+            worker.onError.listen((event) {
+              if (event is ErrorEvent) {
+                fail('Error ${event.message} - ${event.error}');
+              } else {
+                fail(event.toString());
+              }
+            });
+            // Inform the worker about the test we want to run
+            worker.postMessage([backend, wasmUri]);
+
+            final response = (await worker.onMessage.first).data as List;
+            final status = response[0] as bool;
+
+            if (!status) {
+              throw 'Exception in worker: $response';
             }
-          });
-          // Inform the worker about the test we want to run
-          worker.postMessage([backend, wasmUri]);
-
-          final response = (await worker.onMessage.first).data as List;
-          final status = response[0] as bool;
-
-          if (!status) {
-            throw 'Exception in worker: $response';
-          }
-        });
+          },
+          onPlatform: <String, Object?>{
+            if (requiresSab)
+              '!chrome && !edge': Skip(
+                'This test requires SharedArrayBuffers that cannot be enabled '
+                'on this platform with a simple `dart test` setup.',
+              ),
+          },
+        );
       }
     },
   );