[v24.x] backport embedding tests to v24.x

node.gyp

@@ -1511,6 +1511,61 @@
       ],
     }, # embedtest
 
+    {
+      'target_name': 'shared_embedtest',
+      'type': 'executable',
+
+      'dependencies': [
+        '<(node_lib_target_name)',
+      ],
+
+      # Don't depend on node.gypi - it otherwise links to
+      # the static libraries and resolve symbols at build time.
+      'include_dirs': [
+        'deps/v8/include',
+      ],
+
+      'sources': [
+        'test/embedding/shared_embedtest.cc',
+      ],
+      'conditions': [
+        [ 'node_shared=="true"', {
+          'defines': [
+            'USING_V8_SHARED',
+            'USING_V8_PLATFORM_SHARED',
+          ],
+          'defines!': [
+            'BUILDING_V8_PLATFORM_SHARED=1',
+            'BUILDING_V8_SHARED=1',
+          ],
+        }, {
+          # Only test shared embedding when Node is built as shared library.
+          'type': 'none',
+        }],
+        # Only test platforms known to work.
+        ['OS not in "mac win linux"', {
+          'type': 'none',
+        }],
+        ['OS=="win"', {
+          'libraries': [
+            'Dbghelp.lib',
+            'winmm.lib',
+            'Ws2_32.lib',
+          ],
+        }],
+        ['OS=="mac"', {
+          'xcode_settings': {
+            'OTHER_LDFLAGS': [ '-Wl,-rpath,@loader_path', ],
+          }
+        }],
+        ['OS=="linux"', {
+          'ldflags': [
+            '-Wl,-rpath,\\$$ORIGIN'
+          ],
+        }],
+      ],
+    }, # shared_embedtest
+
     {
       'target_name': 'overlapped-checker',
       'type': 'executable',

test/common/index.js

@@ -51,6 +51,8 @@ if (isMainThread)
 
 const noop = () => {};
 
+// Whether the executable is linked against the shared library i.e. libnode.
+const usesSharedLibrary = process.config.variables.node_shared;
 const hasCrypto = Boolean(process.versions.openssl) &&
                   !process.env.NODE_SKIP_CRYPTO;
 
@@ -923,6 +925,13 @@ function sleepSync(ms) {
   Atomics.wait(i32, 0, 0, ms);
 }
 
+function resolveBuiltBinary(binary) {
+  if (isWindows) {
+    binary += '.exe';
+  }
+  return path.join(path.dirname(process.execPath), binary);
+}
+
 const common = {
   allowGlobals,
   buildType,
@@ -967,6 +976,7 @@ const common = {
   printSkipMessage,
   pwdCommand,
   requireNoPackageJSONAbove,
+  resolveBuiltBinary,
   runWithInvalidFD,
   skip,
   skipIf32Bits,
@@ -975,6 +985,7 @@ const common = {
   skipIfSQLiteMissing,
   spawnPromisified,
   sleepSync,
+  usesSharedLibrary,
 
   get enoughTestMem() {
     return require('os').totalmem() > 0x70000000; /* 1.75 Gb */

test/embedding/shared_embedtest.cc

@@ -0,0 +1,60 @@
+#include <libplatform/libplatform.h>
+#include <v8-cppgc.h>
+#include <v8.h>
+
+#include <cppgc/allocation.h>
+#include <cppgc/default-platform.h>
+#include <cppgc/garbage-collected.h>
+#include <cppgc/heap.h>
+#include <cppgc/member.h>
+#include <cppgc/platform.h>
+#include <cppgc/visitor.h>
+
+class Wrappable : public v8::Object::Wrappable {
+ public:
+  void Trace(cppgc::Visitor* visitor) const override {
+    v8::Object::Wrappable::Trace(visitor);
+  }
+};
+
+int main(int argc, char* argv[]) {
+  std::unique_ptr<v8::Platform> platform = v8::platform::NewDefaultPlatform();
+  v8::V8::InitializePlatform(platform.get());
+  cppgc::InitializeProcess(platform->GetPageAllocator());
+  v8::V8::Initialize();
+
+  auto heap = v8::CppHeap::Create(platform.get(), v8::CppHeapCreateParams{{}});
+  v8::Isolate::CreateParams create_params;
+  create_params.array_buffer_allocator =
+      v8::ArrayBuffer::Allocator::NewDefaultAllocator();
+  create_params.cpp_heap = heap.release();
+
+  v8::Isolate* isolate = v8::Isolate::New(create_params);
+  {
+    v8::Isolate::Scope isolate_scope(isolate);
+    v8::HandleScope handle_scope(isolate);
+    v8::Local<v8::Context> context = v8::Context::New(isolate);
+    v8::Context::Scope context_scope(context);
+
+    v8::Local<v8::Object> obj = v8::Object::New(isolate);
+    Wrappable* wrappable = cppgc::MakeGarbageCollected<Wrappable>(
+        isolate->GetCppHeap()->GetAllocationHandle());
+    v8::Object::Wrap<v8::CppHeapPointerTag::kDefaultTag>(
+        isolate, obj, wrappable);
+    v8::Local<v8::String> source =
+        v8::String::NewFromUtf8Literal(isolate, "'Hello' + ', World!'");
+    v8::Local<v8::Script> script =
+        v8::Script::Compile(context, source).ToLocalChecked();
+    v8::Local<v8::Value> result = script->Run(context).ToLocalChecked();
+    v8::String::Utf8Value utf8(isolate, result);
+    printf("%s\n", *utf8);
+  }
+
+  isolate->Dispose();
+  cppgc::ShutdownProcess();
+  v8::V8::Dispose();
+  v8::V8::DisposePlatform();
+  delete create_params.array_buffer_allocator;
+
+  return 0;
+}

test/embedding/test-embedding-create-require-fs.js

@@ -0,0 +1,17 @@
+'use strict';
+
+// Tests that createRequire() works correctly with local fs in embedded environments.
+// The createRequire() call is in embedtest.cc.
+
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+const { spawnSyncAndExit } = require('../common/child_process');
+
+const fixturePath = JSON.stringify(fixtures.path('exit.js'));
+spawnSyncAndExit(
+  common.resolveBuiltBinary('embedtest'),
+  [`require(${fixturePath})`, 92],
+  {
+    status: 92,
+    signal: null,
+  });

test/embedding/test-embedding-create-require-internal.js

@@ -0,0 +1,15 @@
+'use strict';
+
+// Tests that createRequire() from embedded environments still cannot access internals.
+// The createRequire() call is in embedtest.cc.
+
+const common = require('../common');
+const { spawnSyncAndExit } = require('../common/child_process');
+
+spawnSyncAndExit(
+  common.resolveBuiltBinary('embedtest'),
+  ['require("lib/internal/test/binding")'],
+  {
+    status: 1,
+    signal: null,
+  });

test/embedding/test-embedding-disable-node-env-vars.js

@@ -0,0 +1,27 @@
+'use strict';
+
+// Tests node::ProcessInitializationFlags::kDisableNodeOptionsEnv works correctly.
+
+const common = require('../common');
+const { spawnSyncAndExit } = require('../common/child_process');
+const os = require('os');
+
+if (process.config.variables.node_without_node_options) {
+  common.skip('NODE_REPL_EXTERNAL_MODULE cannot be tested with --without-node-options');
+}
+
+const embedtest = common.resolveBuiltBinary('embedtest');
+spawnSyncAndExit(
+  embedtest,
+  ['require("os")'],
+  {
+    env: {
+      ...process.env,
+      'NODE_REPL_EXTERNAL_MODULE': 'fs',
+    },
+  },
+  {
+    status: 9,
+    signal: null,
+    stderr: `${embedtest}: NODE_REPL_EXTERNAL_MODULE can't be used with kDisableNodeOptionsEnv${os.EOL}`,
+  });

test/embedding/test-embedding-exit-code.js

@@ -0,0 +1,14 @@
+'use strict';
+
+// Tests that process.exitCode works correctly in embedded environments.
+
+const common = require('../common');
+const { spawnSyncAndExit } = require('../common/child_process');
+
+spawnSyncAndExit(
+  common.resolveBuiltBinary('embedtest'),
+  ['process.exitCode = 8'],
+  {
+    status: 8,
+    signal: null,
+  });

test/embedding/test-embedding-load-environment-basic.js

@@ -0,0 +1,16 @@
+'use strict';
+
+// Tests node::LoadEnvironment() with main_script_source_utf8 works.
+
+const common = require('../common');
+const { spawnSyncAndAssert } = require('../common/child_process');
+
+const embedtest = common.resolveBuiltBinary('embedtest');
+
+spawnSyncAndAssert(
+  embedtest,
+  ['console.log(42)'],
+  {
+    trim: true,
+    stdout: '42',
+  });

test/embedding/test-embedding-load-environment-utf8.js

@@ -0,0 +1,17 @@
+'use strict';
+
+// Test node::LoadEnvironment() works with non-ASCII source code. The variable
+// comes from embedtest.cc.
+
+const common = require('../common');
+const { spawnSyncAndAssert } = require('../common/child_process');
+
+const embedtest = common.resolveBuiltBinary('embedtest');
+
+spawnSyncAndAssert(
+  embedtest,
+  ['console.log(embedVars.nön_ascıı)'],
+  {
+    trim: true,
+    stdout: '🏳️‍🌈',
+  });

test/embedding/test-embedding-snapshot-as-file.js

@@ -0,0 +1,50 @@
+'use strict';
+
+// Tests node::EmbedderSnapshotData::FromFile() works correctly.
+// The snapshot is created in embedtest.cc.
+
+const common = require('../common');
+const tmpdir = require('../common/tmpdir');
+const assert = require('assert');
+const fixtures = require('../common/fixtures');
+
+const {
+  spawnSyncAndAssert,
+  spawnSyncAndExitWithoutError,
+} = require('../common/child_process');
+
+const snapshotFixture = fixtures.path('snapshot', 'echo-args.js');
+const embedtest = common.resolveBuiltBinary('embedtest');
+
+const buildSnapshotExecArgs = [
+  `eval(require("fs").readFileSync(${JSON.stringify(snapshotFixture)}, "utf8"))`,
+  'arg1', 'arg2',
+];
+const snapshotBlobArgs = [
+  '--embedder-snapshot-blob', tmpdir.resolve('embedder-snapshot.blob'),
+];
+
+const runSnapshotExecArgs = ['arg3', 'arg4'];
+
+tmpdir.refresh();
+
+// Build the snapshot with the --embedder-snapshot-as-file flag.
+spawnSyncAndExitWithoutError(
+  embedtest,
+  ['--', ...buildSnapshotExecArgs, ...snapshotBlobArgs, '--embedder-snapshot-as-file', '--embedder-snapshot-create'],
+  { cwd: tmpdir.path });
+
+// Run the snapshot and check the serialized and refreshed argv values.
+spawnSyncAndAssert(
+  embedtest,
+  ['--', ...runSnapshotExecArgs, ...snapshotBlobArgs ],
+  { cwd: tmpdir.path },
+  {
+    stdout(output) {
+      assert.deepStrictEqual(JSON.parse(output), {
+        originalArgv: [embedtest, '__node_anonymous_main', ...buildSnapshotExecArgs],
+        currentArgv: [embedtest, ...runSnapshotExecArgs],
+      });
+      return true;
+    },
+  });

test/embedding/test-embedding-snapshot-basic.js

@@ -0,0 +1,50 @@
+'use strict';
+
+// Tests snapshot support in embedded environments.
+// See embedtest.cc for the API usage.
+
+const common = require('../common');
+const tmpdir = require('../common/tmpdir');
+const assert = require('assert');
+const fixtures = require('../common/fixtures');
+
+const {
+  spawnSyncAndAssert,
+  spawnSyncAndExitWithoutError,
+} = require('../common/child_process');
+
+const snapshotFixture = fixtures.path('snapshot', 'echo-args.js');
+const embedtest = common.resolveBuiltBinary('embedtest');
+
+const buildSnapshotExecArgs = [
+  `eval(require("fs").readFileSync(${JSON.stringify(snapshotFixture)}, "utf8"))`,
+  'arg1', 'arg2',
+];
+const snapshotBlobArgs = [
+  '--embedder-snapshot-blob', tmpdir.resolve('embedder-snapshot.blob'),
+];
+
+const runSnapshotExecArgs = ['arg3', 'arg4'];
+
+tmpdir.refresh();
+
+// Build the snapshot with the default flags.
+spawnSyncAndExitWithoutError(
+  embedtest,
+  ['--', ...buildSnapshotExecArgs, ...snapshotBlobArgs, '--embedder-snapshot-create'],
+  { cwd: tmpdir.path });
+
+// Run the snapshot and check the serialized and refreshed argv values.
+spawnSyncAndAssert(
+  embedtest,
+  ['--', ...runSnapshotExecArgs, ...snapshotBlobArgs ],
+  { cwd: tmpdir.path },
+  {
+    stdout(output) {
+      assert.deepStrictEqual(JSON.parse(output), {
+        originalArgv: [embedtest, '__node_anonymous_main', ...buildSnapshotExecArgs],
+        currentArgv: [embedtest, ...runSnapshotExecArgs],
+      });
+      return true;
+    },
+  });