fixup! test add

Author: himself65

src/node_errors.h

@@ -91,6 +91,7 @@ void OOMErrorHandler(const char* location, const v8::OOMDetails& details);
   V(ERR_INVALID_THIS, TypeError)                                               \
   V(ERR_INVALID_URL, TypeError)                                                \
   V(ERR_INVALID_URL_SCHEME, TypeError)                                         \
+  V(ERR_LOAD_SQLITE_EXTENSION, Error)                                          \
   V(ERR_MEMORY_ALLOCATION_FAILED, Error)                                       \
   V(ERR_MESSAGE_TARGET_CONTEXT_UNAVAILABLE, Error)                             \
   V(ERR_MISSING_ARGS, TypeError)                                               \
@@ -186,6 +187,7 @@ ERRORS_WITH_CODE(V)
   V(ERR_INVALID_STATE, "Invalid state")                                        \
   V(ERR_INVALID_THIS, "Value of \"this\" is the wrong type")                   \
   V(ERR_INVALID_URL_SCHEME, "The URL must be of scheme file:")                 \
+  V(ERR_LOAD_SQLITE_EXTENSION, "Failed to load SQLite extension")              \
   V(ERR_MEMORY_ALLOCATION_FAILED, "Failed to allocate memory")                 \
   V(ERR_OSSL_EVP_INVALID_DIGEST, "Invalid digest used")                        \
   V(ERR_MESSAGE_TARGET_CONTEXT_UNAVAILABLE,                                    \

src/node_sqlite.cc

@@ -253,13 +253,18 @@ void DatabaseSync::LoadExtension(const FunctionCallbackInfo<Value>& args) {
     return;
   }
 
-  BufferValue path(env->isolate(), args[0]);
+  auto isolate = env->isolate();
+
+  BufferValue path(isolate, args[0]);
   CHECK_NOT_NULL(*path);
   ToNamespacedPath(env, &path);
   THROW_IF_INSUFFICIENT_PERMISSIONS(
       env, permission::PermissionScope::kFileSystemRead, path.ToStringView());
-  int r = sqlite3_load_extension(db->connection_, *path, nullptr, nullptr);
-  CHECK_ERROR_OR_THROW(env->isolate(), db->connection_, r, SQLITE_OK, void());
+  char* errmsg = nullptr;
+  int r = sqlite3_load_extension(db->connection_, *path, nullptr, &errmsg);
+  if (r != SQLITE_OK) {
+    isolate->ThrowException(node::ERR_LOAD_SQLITE_EXTENSION(isolate, errmsg));
+  }
 }
 
 StatementSync::StatementSync(Environment* env,

test/parallel/test-sqlite.js

@@ -92,29 +92,75 @@ suite('DatabaseSync() constructor', () => {
 });
 
 suite('DatabaseSync.prototype.loadExtension()', () => {
+  test('throws if database is not open', (t) => {
+    const db = new DatabaseSync(nextDb(), { open: false });
+    t.assert.throws(() => {
+      db.loadExtension();
+    }, {
+      code: 'ERR_INVALID_STATE',
+      message: /database is not open/,
+    });
+  });
+
+  test('throws if path is not a valid sqlite extension', (t) => {
+    const db = new DatabaseSync(nextDb(), {
+      allowLoadExtension: true,
+    });
+    // Try to load a non-existent file
+    const files = [
+      '/dev/null',
+      path('a.js'),
+      path('shared-memory.wasm'),
+      path('crash.wat'),
+      path('doc_inc_1.md'),
+      path('utf8-bom.json'),
+      path('x.txt'),
+    ];
+    for (const file of files) {
+      t.assert.throws(() => {
+        db.loadExtension(file);
+      }, {
+        code: 'ERR_LOAD_SQLITE_EXTENSION',
+      }, `loadExtension("${file}") should throw an error`);
+    }
+  });
+
   test('loads an extension', (t) => {
     const dbPath = nextDb();
     const db = new DatabaseSync(dbPath, { allowLoadExtension: true });
     const supportedPlatforms = [
-      ["macos","x86_64"],
-      ["windows","x86_64"],
-      ["linux","x86_64"],
-      ["macos","aarch64"]
+      ['macos', 'x86_64'],
+      ['windows', 'x86_64'],
+      ['linux', 'x86_64'],
+      ['macos', 'aarch64'],
     ];
     function validPlatform(platform, arch) {
       return (
-          supportedPlatforms.find(([p, a]) => platform == p && arch === a) !== null
+        supportedPlatforms.find(([p, a]) => platform === p && arch === a) !== null
       );
     }
+
+    function getExtension(platform, arch) {
+      switch (platform) {
+        case 'darwin':
+          return arch === 'arm64' ? '.aarch64.dylib' : '.x86_64.dylib';
+        case 'windows':
+          return '.dll';
+        case 'linux':
+          return '.so';
+        default:
+          return null;
+      }
+    }
     const platform = os.platform();
-    const arch = os.arch();
+    const arch = process.arch;
     if (!validPlatform(platform, arch)) {
-      t.skip();
+      t.skip('Unsupported platform');
       return;
     }
-    const ext = platform === 'win32' ? 'dll' : platform === 'darwin' ? process.arch === 'arm64' ? '.aarch64.dylib' : '.x86_64.dylib' : 'so';
-    const extension = path('sqlite', `vec0${ext}`)
-    t.assert.strictEqual(db.loadExtension(extension), undefined);
+    const ext = getExtension(platform, arch);
+    const filePath = path('sqlite', `vec0${ext}`);
+    t.assert.strictEqual(db.loadExtension(filePath), undefined);
   });
 });