Add a comprehensive IDBFS autopersist test

Author: handlerug

test/fs/test_idbfs_autopersist.c

@@ -0,0 +1,208 @@
+/*
+ * Copyright 2025 The Emscripten Authors.  All rights reserved.
+ * Emscripten is available under two separate licenses, the MIT license and the
+ * University of Illinois/NCSA Open Source License.  Both these licenses can be
+ * found in the LICENSE file.
+ */
+
+#include <assert.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <emscripten.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <errno.h>
+
+EM_JS_DEPS(deps, "$callUserCallback");
+
+void finish() {
+  emscripten_force_exit(0);
+}
+
+static void prepare() {
+  printf("cleaning up test files\n");
+  unlink("/working1/file");
+  unlink("/working1/file_renamed");
+  unlink("/working1/symlink");
+  rmdir("/working1/dir");
+}
+
+void test() {
+#ifdef TEST_PREPARE
+  prepare();
+  goto end;
+#endif
+
+  int res;
+  struct stat st;
+
+  enum {
+    TEST_CASE_open = 0,
+    TEST_CASE_close,
+    TEST_CASE_symlink,
+    TEST_CASE_unlink,
+    TEST_CASE_rename,
+    TEST_CASE_mkdir,
+  };
+
+  switch (TEST_CASE) {
+    case TEST_CASE_open:
+      switch (TEST_PHASE) {
+        case 1: {
+          int fd = open("/working1/file", O_RDWR | O_CREAT | O_EXCL, 0777);
+          assert(fd != -1);
+          break;
+        }
+        case 2: {
+          res = lstat("/working1/file", &st);
+          assert(res == 0);
+          assert(st.st_size == 0);
+          break;
+        }
+        default:
+          assert(false);
+      }
+      break;
+
+    case TEST_CASE_close:
+      switch (TEST_PHASE) {
+        case 1: {
+          int fd = open("/working1/file", O_RDWR, 0777);
+          assert(fd != -1);
+          ssize_t bytes_written = write(fd, "foo", 3);
+          assert(bytes_written == 3);
+          res = close(fd);
+          assert(res == 0);
+          break;
+        }
+        case 2: {
+          res = lstat("/working1/file", &st);
+          assert(res == 0);
+          assert(st.st_size == 3);
+          break;
+        }
+        default:
+          assert(false);
+      }
+      break;
+
+    case TEST_CASE_symlink:
+      switch (TEST_PHASE) {
+        case 1: {
+          res = symlink("/working1/file", "/working1/symlink");
+          assert(res == 0);
+          break;
+        }
+        case 2: {
+          res = lstat("/working1/symlink", &st);
+          assert(res == 0);
+          break;
+        }
+        default:
+          assert(false);
+      }
+      break;
+
+    case TEST_CASE_unlink:
+      switch (TEST_PHASE) {
+        case 1: {
+          res = unlink("/working1/symlink");
+          assert(res == 0);
+          break;
+        }
+        case 2: {
+          res = lstat("/working1/symlink", &st);
+          assert(res == -1);
+          assert(errno == ENOENT);
+          break;
+        }
+        default:
+          assert(false);
+      }
+      break;
+
+    case TEST_CASE_rename:
+      switch (TEST_PHASE) {
+        case 1: {
+          res = rename("/working1/file", "/working1/file_renamed");
+          assert(res == 0);
+          break;
+        }
+        case 2: {
+          res = lstat("/working1/file_renamed", &st);
+          assert(res == 0);
+          res = lstat("/working1/file", &st);
+          assert(res == -1);
+          assert(errno == ENOENT);
+          break;
+        }
+        default:
+          assert(false);
+      }
+      break;
+
+    case TEST_CASE_mkdir:
+      switch (TEST_PHASE) {
+        case 1: {
+          res = mkdir("/working1/dir", 0777);
+          assert(res == 0);
+          break;
+        }
+        case 2: {
+          res = lstat("/working1/dir", &st);
+          assert(res == 0);
+          break;
+        }
+        default:
+          assert(false);
+      }
+      break;
+
+    default:
+      assert(false);
+  }
+
+end:
+  EM_ASM({
+    // Wait until IDBFS has persisted before exiting
+    runOnceIDBFSIdle(() => {
+      callUserCallback(_finish);
+    });
+  });
+}
+
+int main() {
+  EM_ASM({
+    globalThis.runOnceIDBFSIdle = (callback) => {
+      const { mount } = FS.lookupPath('/working1').node;
+      assert('idbPersistState' in mount, 'mount object must have idbPersistState');
+      if (mount.idbPersistState !== 0) {
+        // IDBFS hasn't finished persisting. Check again after all pending tasks have executed
+        setTimeout(() => runOnceIDBFSIdle(callback), 0);
+        return;
+      }
+      callback();
+    };
+
+    FS.mkdir('/working1');
+    FS.mount(IDBFS, {
+      autoPersist: true
+    }, '/working1');
+
+    // Sync from persisted state into memory
+    FS.syncfs(true, (err) => {
+      assert(!err);
+
+      // The resulting filesystem modifications might trigger IDBFS.queuePersist()
+      // calls which will interfere with the shutdown code. Wait until all such
+      // calls have completed.
+      runOnceIDBFSIdle(() => {
+        callUserCallback(_test);
+      });
+    });
+  });
+
+  emscripten_exit_with_live_runtime();
+  return 0;
+}

test/test_browser.py

@@ -1353,6 +1353,32 @@ def test_fs_idbfs_sync(self, args):
     print('done first half')
     self.btest_exit('fs/test_idbfs_sync.c', cflags=['-lidbfs.js', f'-DSECRET="{secret}"', '-sEXPORTED_FUNCTIONS=_main,_test,_finish', '-lidbfs.js'] + args)
 
+  def test_fs_idbfs_autopersist(self):
+    common_cflags = ['-lidbfs.js', '-sEXPORTED_FUNCTIONS=_main,_test,_finish']
+    test_cases = [
+      'open',
+      'close',
+      'symlink',
+      'unlink',
+      'rename',
+      'mkdir',
+    ]
+
+    def get_defines(current_case_name, phase):
+      return [
+        f'-DTEST_CASE={test_cases.index(current_case_name) if current_case_name in test_cases else -1}',
+        f'-DTEST_PHASE={phase}',
+      ]
+
+    print('preparing')
+    self.btest_exit('fs/test_idbfs_autopersist.c', cflags=common_cflags + get_defines(None, 0) + ['-DTEST_PREPARE'])
+
+    for current_case_name in test_cases:
+      print(f'testing {current_case_name}: executing operation')
+      self.btest_exit('fs/test_idbfs_autopersist.c', cflags=common_cflags + get_defines(current_case_name, phase=1))
+      print(f'testing {current_case_name}: checking if the operation has persisted')
+      self.btest_exit('fs/test_idbfs_autopersist.c', cflags=common_cflags + get_defines(current_case_name, phase=2))
+
   def test_fs_idbfs_fsync(self):
     # sync from persisted state into memory before main()
     self.set_setting('DEFAULT_LIBRARY_FUNCS_TO_INCLUDE', '$ccall')