#include "libplatform/libplatform.h"
#include "node_buffer.h"
#include "node_internals.h"
#include "node_realm-inl.h"
#include "node_snapshot_builder.h"
#include "node_url.h"
#include "util.h"
#include <stdio.h>
#include <cstdio>
#include <string>
#include <thread> // NOLINT(build/c++11)
#include "gtest/gtest.h"
#include "node_test_fixture.h"
using node::AtExit;
using node::RunAtExit;
using node::USE;
using v8::Context;
using v8::Local;
static bool called_cb_1 = false;
static bool called_cb_2 = false;
static bool called_cb_ordered_1 = false;
static bool called_cb_ordered_2 = false;
static bool called_at_exit_js = false;
static void at_exit_callback1(void* arg);
static void at_exit_callback2(void* arg);
static void at_exit_callback_ordered1(void* arg);
static void at_exit_callback_ordered2(void* arg);
static void at_exit_js(void* arg);
static std::string cb_1_arg; // NOLINT(runtime/string)
struct SelfRemovingCleanupHookState {
v8::Isolate* isolate;
bool ran = false;
};
static void self_removing_cleanup_hook(void* arg);
class EnvironmentTest : public EnvironmentTestFixture {
private:
void TearDown() override {
EnvironmentTestFixture::TearDown();
called_cb_1 = false;
called_cb_2 = false;
called_cb_ordered_1 = false;
called_cb_ordered_2 = false;
}
};
TEST_F(EnvironmentTest, ManagedBufferCache) {
constexpr size_t kCacheSize = 64 * 1024;
constexpr size_t kOtherSize = 1024;
const v8::HandleScope handle_scope(isolate_);
Argv argv;
Env env{handle_scope, argv};
(*env)->recycle_managed_buffer(nullptr);
uv_buf_t buffer = (*env)->allocate_managed_buffer(kCacheSize);
char* cached_data = buffer.base;
(*env)->recycle_managed_buffer((*env)->release_managed_buffer(buffer));
buffer = (*env)->allocate_managed_buffer(kOtherSize);
(*env)->recycle_managed_buffer((*env)->release_managed_buffer(buffer));
buffer = (*env)->allocate_managed_buffer(kCacheSize);
EXPECT_EQ(buffer.base, cached_data);
(*env)->release_managed_buffer(buffer);
}
static int embedder_wasm_streaming_calls = 0;
static void EmbedderWasmStreaming(const v8::FunctionCallbackInfo<v8::Value>&) {
embedder_wasm_streaming_calls++;
}
TEST_F(EnvironmentTest, KeepsEmbedderWasmStreamingCallbackWhenAsked) {
const v8::HandleScope handle_scope(isolate_);
const Argv argv;
Env env{handle_scope, argv};
auto compile_streaming = [&]() {
v8::Local<v8::Context> context = isolate_->GetCurrentContext();
v8::Script::Compile(context,
v8::String::NewFromUtf8Literal(
isolate_, "WebAssembly.compileStreaming(0); 0"))
.ToLocalChecked()
->Run(context)
.ToLocalChecked();
isolate_->PerformMicrotaskCheckpoint();
};
node::IsolateSettings settings;
settings.flags |= node::SHOULD_NOT_SET_WASM_STREAMING_CALLBACK;
isolate_->SetWasmStreamingCallback(EmbedderWasmStreaming);
node::SetIsolateUpForNode(isolate_, settings);
compile_streaming();
EXPECT_EQ(embedder_wasm_streaming_calls, 1);
node::SetIsolateUpForNode(isolate_);
compile_streaming();
EXPECT_EQ(embedder_wasm_streaming_calls, 1);
}
TEST_F(EnvironmentTest, EnvironmentWithoutBrowserGlobals) {
const v8::HandleScope handle_scope(isolate_);
Argv argv;
Env env{handle_scope, argv, node::EnvironmentFlags::kNoBrowserGlobals};
SetProcessExitHandler(*env, [&](node::Environment* env_, int exit_code) {
EXPECT_EQ(*env, env_);
EXPECT_EQ(exit_code, 0);
node::Stop(*env);
});
node::LoadEnvironment(
*env,
"const assert = require('assert');"
"const path = require('path');"
"const relativeRequire = "
" require('module').createRequire(path.join(process.cwd(), 'stub.js'));"
"const { intrinsics, nodeGlobals } = "
" relativeRequire('./test/common/globals');"
"const items = Object.getOwnPropertyNames(globalThis);"
"const leaks = [];"
"for (const item of items) {"
" if (intrinsics.has(item)) {"
" continue;"
" }"
" if (nodeGlobals.has(item)) {"
" continue;"
" }"
" leaks.push(item);"
"}"
"assert.deepStrictEqual(leaks, []);");
}
TEST_F(EnvironmentTest, EnvironmentWithESMLoader) {
const v8::HandleScope handle_scope(isolate_);
Argv argv;
Env env {handle_scope, argv};
node::Environment* envi = *env;
envi->options()->experimental_vm_modules = true;
SetProcessExitHandler(*env, [&](node::Environment* env_, int exit_code) {
EXPECT_EQ(*env, env_);
EXPECT_EQ(exit_code, 0);
node::Stop(*env);
});
node::LoadEnvironment(
*env,
"const { SourceTextModule } = require('vm');"
"(async () => {"
"const stmString = 'globalThis.importResult = import(\"\")';"
"const m = new SourceTextModule(stmString, {"
"importModuleDynamically: (async () => {"
"const m = new SourceTextModule('');"
"await m.link(() => 0);"
"await m.evaluate();"
"return m.namespace;"
"}),"
"});"
"await m.link(() => 0);"
"await m.evaluate();"
"delete globalThis.importResult;"
"process.exit(0);"
"})()");
}
class RedirectStdErr {
public:
explicit RedirectStdErr(const char* filename) : filename_(filename) {
fflush(stderr);
fgetpos(stderr, &pos_);
fd_ = dup(fileno(stderr));
USE(freopen(filename_, "w", stderr));
}
~RedirectStdErr() {
fflush(stderr);
dup2(fd_, fileno(stderr));
close(fd_);
remove(filename_);
clearerr(stderr);
fsetpos(stderr, &pos_);
}
private:
int fd_;
fpos_t pos_;
const char* filename_;
};
TEST_F(EnvironmentTest, EnvironmentWithNoESMLoader) {
// The following line will cause stderr to get redirected to avoid the
// error that would otherwise be printed to the console by this test.
RedirectStdErr redirect_scope("environment_test.log");
const v8::HandleScope handle_scope(isolate_);
Argv argv;
Env env {handle_scope, argv, node::EnvironmentFlags::kNoRegisterESMLoader};
node::Environment* envi = *env;
envi->options()->experimental_vm_modules = true;
SetProcessExitHandler(*env, [&](node::Environment* env_, int exit_code) {
EXPECT_EQ(*env, env_);
EXPECT_EQ(exit_code, 1);
node::Stop(*env);
});
node::LoadEnvironment(
*env,
"const { SourceTextModule } = require('vm');"
"(async () => {"
"const stmString = 'globalThis.importResult = import(\"\")';"
"const m = new SourceTextModule(stmString, {"
"importModuleDynamically: (async () => {"
"const m = new SourceTextModule('');"
"await m.link(() => 0);"
"await m.evaluate();"
"return m.namespace;"
"}),"
"});"
"await m.link(() => 0);"
"await m.evaluate();"
"delete globalThis.importResult;"
"})()");
}
TEST_F(EnvironmentTest, PreExecutionPreparation) {
const v8::HandleScope handle_scope(isolate_);
const Argv argv;
Env env {handle_scope, argv};
node::LoadEnvironment(*env, [&](const node::StartExecutionCallbackInfo& info)
-> v8::MaybeLocal<v8::Value> {
return v8::Null(isolate_);
});
v8::Local<v8::Context> context = isolate_->GetCurrentContext();
const char* run_script = "process.argv0";
v8::Local<v8::Script> script = v8::Script::Compile(
context,
v8::String::NewFromOneByte(isolate_,
reinterpret_cast<const uint8_t*>(run_script))
.ToLocalChecked())
.ToLocalChecked();
v8::Local<v8::Value> result = script->Run(context).ToLocalChecked();
CHECK(result->IsString());
}
TEST_F(EnvironmentTest, LoadEnvironmentWithCallback) {
const v8::HandleScope handle_scope(isolate_);
const Argv argv;
Env env {handle_scope, argv};
v8::Local<v8::Context> context = isolate_->GetCurrentContext();
bool called_cb = false;
node::LoadEnvironment(*env,
[&](const node::StartExecutionCallbackInfo& info)
-> v8::MaybeLocal<v8::Value> {
called_cb = true;
CHECK(info.process_object->IsObject());
CHECK(info.native_require->IsFunction());
v8::Local<v8::Value> argv0 = info.process_object->Get(
context,
v8::String::NewFromOneByte(
isolate_,
reinterpret_cast<const uint8_t*>("argv0"))
.ToLocalChecked()).ToLocalChecked();
CHECK(argv0->IsString());
return info.process_object;
});
CHECK(called_cb);
}
TEST_F(EnvironmentTest, LoadEnvironmentWithSource) {
const v8::HandleScope handle_scope(isolate_);
const Argv argv;
Env env {handle_scope, argv};
v8::Local<v8::Context> context = isolate_->GetCurrentContext();
v8::Local<v8::Value> main_ret =
node::LoadEnvironment(*env,
"return { process, require };").ToLocalChecked();
CHECK(main_ret->IsObject());
CHECK(main_ret.As<v8::Object>()->Get(
context,
v8::String::NewFromOneByte(
isolate_,
reinterpret_cast<const uint8_t*>("process"))
.ToLocalChecked())
.ToLocalChecked()->IsObject());
CHECK(main_ret.As<v8::Object>()->Get(
context,
v8::String::NewFromOneByte(
isolate_,
reinterpret_cast<const uint8_t*>("require"))
.ToLocalChecked())
.ToLocalChecked()->IsFunction());
}
TEST_F(EnvironmentTest, AtExitWithEnvironment) {
const v8::HandleScope handle_scope(isolate_);
const Argv argv;
Env env {handle_scope, argv};
AtExit(*env, at_exit_callback1, nullptr);
RunAtExit(*env);
EXPECT_TRUE(called_cb_1);
}
TEST_F(EnvironmentTest, AtExitOrder) {
const v8::HandleScope handle_scope(isolate_);
const Argv argv;
Env env {handle_scope, argv};
// Test that callbacks are run in reverse order.
AtExit(*env, at_exit_callback_ordered1, nullptr);
AtExit(*env, at_exit_callback_ordered2, nullptr);
RunAtExit(*env);
EXPECT_TRUE(called_cb_ordered_1);
EXPECT_TRUE(called_cb_ordered_2);
}
TEST_F(EnvironmentTest, AtExitWithArgument) {
const v8::HandleScope handle_scope(isolate_);
const Argv argv;
Env env {handle_scope, argv};
std::string arg{"some args"};
AtExit(*env, at_exit_callback1, static_cast<void*>(&arg));
RunAtExit(*env);
EXPECT_EQ(arg, cb_1_arg);
}
TEST_F(EnvironmentTest, AtExitRunsJS) {
const v8::HandleScope handle_scope(isolate_);
const Argv argv;
Env env {handle_scope, argv};
AtExit(*env, at_exit_js, static_cast<void*>(isolate_));
EXPECT_FALSE(called_at_exit_js);
RunAtExit(*env);
EXPECT_TRUE(called_at_exit_js);
}
// A cleanup hook that removes itself while the environment cleanup queue is
// being drained must not cause a use-after-free. This registers such a hook
// directly rather than through node::ObjectWrap, whose destructor removes
// its own hook and is what makes this reachable for addons since #63642.
// The use-after-free is silent in ordinary builds; it is caught by the
// ASan/Valgrind CI, which is also how the original assertion (#63923)
// surfaced. Regression test for https://github.com/nodejs/node/issues/65195.
TEST_F(EnvironmentTest, RemoveEnvironmentCleanupHookDuringCleanup) {
const v8::HandleScope handle_scope(isolate_);
const Argv argv;
SelfRemovingCleanupHookState state{isolate_};
{
Env env{handle_scope, argv};
node::AddEnvironmentCleanupHook(
isolate_, self_removing_cleanup_hook, &state);
// Destroying `env` runs FreeEnvironment() -> RunCleanup(), which drains
// the cleanup queue and invokes CleanupHookThunkRun() for the hook above.
}
EXPECT_TRUE(state.ran);
}
TEST_F(EnvironmentTest, MultipleEnvironmentsPerIsolate) {
const v8::HandleScope handle_scope(isolate_);
const Argv argv;
Env env1 {handle_scope, argv};
Env env2{handle_scope, argv};
AtExit(*env1, at_exit_callback1, nullptr);
AtExit(*env2, at_exit_callback2, nullptr);
RunAtExit(*env1);
EXPECT_TRUE(called_cb_1);
EXPECT_FALSE(called_cb_2);
RunAtExit(*env2);
EXPECT_TRUE(called_cb_2);
}
TEST_F(EnvironmentTest, WorkerInEnvironmentWithoutSnapshot) {
const v8::HandleScope handle_scope(isolate_);
const Argv argv;
Env env{handle_scope, argv};
// When using certain experimental compile options, snapshot data may
// not exist. Skip in that case.
if (isolate_data_->snapshot_data()) {
node::LoadEnvironment(*env,
"const { Worker } = require('worker_threads');"
"new Worker('process.exit(0)', { eval: true });")
.ToLocalChecked();
EXPECT_EQ(node::SpinEventLoop(*env).FromJust(), 0);
}
}
TEST_F(EnvironmentTest, StopFromExitHandlerDoesNotLeakIntoNextEnvironment) {
const v8::HandleScope handle_scope(isolate_);
const Argv argv;
{
Env env{handle_scope, argv};
node::SetProcessExitHandler(
*env, [](node::Environment* env_, int) { node::Stop(env_); });
// The uncaught exception runs the exit handler from C++ and does not
// re-enter JS afterwards, so nothing consumes the termination request.
EXPECT_TRUE(
node::LoadEnvironment(*env, "throw new Error('uncaught')").IsEmpty());
EXPECT_TRUE(node::SpinEventLoop(*env).IsNothing());
}
{
Env env{handle_scope, argv, node::EnvironmentFlags::kNoCreateInspector};
v8::Local<v8::Value> result =
node::LoadEnvironment(*env, "return 42;").ToLocalChecked();
EXPECT_EQ(result->Int32Value(env.context()).FromJust(), 42);
}
}
TEST_F(EnvironmentTest, CollectExternalReferencesFromSeveralThreads) {
constexpr int kThreads = 8;
const intptr_t* data[kThreads];
size_t sizes[kThreads];
std::vector<std::thread> threads;
for (int i = 0; i < kThreads; i++) {
threads.emplace_back([&, i]() {
const std::vector<intptr_t>& references =
node::SnapshotBuilder::CollectExternalReferences();
data[i] = references.data();
sizes[i] = references.size();
});
}
for (std::thread& thread : threads) thread.join();
for (int i = 1; i < kThreads; i++) {
EXPECT_EQ(data[i], data[0]);
EXPECT_EQ(sizes[i], sizes[0]);
}
EXPECT_EQ(node::SnapshotBuilder::CollectExternalReferences().back(), 0);
}
TEST_F(EnvironmentTest, SharedIsolateDataLoadsBindingsTwice) {
const v8::HandleScope handle_scope(isolate_);
const Argv argv;
const char* script =
"for (const m of require('module').builtinModules) {"
" try { require(m); } catch {}"
"}"
"new (require('net').Socket)();"
#if HAVE_OPENSSL
"require('tls').createSecureContext();"
"require('crypto').createSecretKey(Buffer.alloc(8));"
#endif
"new (require('worker_threads').MessageChannel)().port1.close();";
Env env1{handle_scope, argv};
node::LoadEnvironment(*env1, script).ToLocalChecked();
EXPECT_EQ(node::SpinEventLoop(*env1).FromJust(), 0);
Env env2{handle_scope, argv, node::EnvironmentFlags::kNoCreateInspector};
node::LoadEnvironment(*env2, script).ToLocalChecked();
EXPECT_EQ(node::SpinEventLoop(*env2).FromJust(), 0);
}
#if HAVE_INSPECTOR
TEST_F(EnvironmentTest, WorkerConnectToMainThreadWithoutInspector) {
const v8::HandleScope handle_scope(isolate_);
const Argv argv;
Env env{handle_scope, argv, node::EnvironmentFlags::kNoCreateInspector};
node::LoadEnvironment(
*env,
"const { Worker } = require('worker_threads');"
"const w = new Worker(`"
" const { Session } = require('inspector');"
" try { new Session().connectToMainThread(); }"
" catch (e) { process.exit(e.code === 'ERR_INSPECTOR_NOT_AVAILABLE' ?"
" 0 : 2); }"
" process.exit(3);"
"`, { eval: true });"
"w.on('exit', (code) => { process.exitCode = code; });")
.ToLocalChecked();
EXPECT_EQ(node::SpinEventLoop(*env).FromJust(), 0);
}
#endif // HAVE_INSPECTOR
static int cleanup_hook_runs = 0;
static void CountingCleanupHook(void* arg) {
cleanup_hook_runs++;
}
TEST_F(EnvironmentTest, SameCleanupHookInTwoEnvironmentsOnOneIsolate) {
const v8::HandleScope handle_scope(isolate_);
const Argv argv;
cleanup_hook_runs = 0;
{
Env env1{handle_scope, argv};
{
Env env2{handle_scope, argv, node::EnvironmentFlags::kNoCreateInspector};
{
v8::Context::Scope context_scope(env1.context());
node::AddEnvironmentCleanupHook(isolate_, CountingCleanupHook, nullptr);
}
node::AddEnvironmentCleanupHook(isolate_, CountingCleanupHook, nullptr);
}
EXPECT_EQ(cleanup_hook_runs, 1);
}
EXPECT_EQ(cleanup_hook_runs, 2);
}
TEST_F(EnvironmentTest, RemoveCleanupHookOfOtherEnvironmentOnSameIsolate) {
const v8::HandleScope handle_scope(isolate_);
const Argv argv;
cleanup_hook_runs = 0;
int arg;
{
Env env1{handle_scope, argv};
node::AddEnvironmentCleanupHook(isolate_, CountingCleanupHook, &arg);
Env env2{handle_scope, argv, node::EnvironmentFlags::kNoCreateInspector};
// env2's context is current; the hook belongs to env1.
node::RemoveEnvironmentCleanupHook(isolate_, CountingCleanupHook, &arg);
}
EXPECT_EQ(cleanup_hook_runs, 0);
}
struct SelfRemovingHook {
v8::Isolate* isolate;
bool ran = false;
static void Run(void* arg) {
SelfRemovingHook* self = static_cast<SelfRemovingHook*>(arg);
self->ran = true;
node::RemoveEnvironmentCleanupHook(self->isolate, Run, arg);
}
};
TEST_F(EnvironmentTest, CleanupHookRemovesItselfWhileRunning) {
const v8::HandleScope handle_scope(isolate_);
const Argv argv;
SelfRemovingHook hook{isolate_};
{
Env env{handle_scope, argv};
node::AddEnvironmentCleanupHook(isolate_, SelfRemovingHook::Run, &hook);
}
EXPECT_TRUE(hook.ran);
}
TEST_F(EnvironmentTest, FreeEnvironmentWhileSiblingHasActiveHandles) {
const v8::HandleScope handle_scope(isolate_);
const Argv argv;
Env env1{handle_scope, argv};
node::LoadEnvironment(*env1,
"globalThis.ticks = 0;"
"const t = setInterval(() => {"
" if (++globalThis.ticks == 20) clearInterval(t);"
"}, 1);")
.ToLocalChecked();
{
Env env2{handle_scope, argv, node::EnvironmentFlags::kNoCreateInspector};
node::LoadEnvironment(*env2, "setInterval(() => {}, 1);").ToLocalChecked();
uv_sleep(5);
}
v8::Context::Scope context_scope(env1.context());
EXPECT_EQ(node::SpinEventLoop(*env1).FromJust(), 0);
v8::Local<v8::Value> ticks =
env1.context()
->Global()
->Get(env1.context(),
v8::String::NewFromUtf8Literal(isolate_, "ticks"))
.ToLocalChecked();
EXPECT_EQ(ticks->Int32Value(env1.context()).FromJust(), 20);
}
TEST_F(EnvironmentTest, NoEnvironmentSanity) {
const v8::HandleScope handle_scope(isolate_);
v8::Local<v8::Context> context = v8::Context::New(isolate_);
EXPECT_EQ(node::Environment::GetCurrent(context), nullptr);
EXPECT_EQ(node::GetCurrentEnvironment(context), nullptr);
EXPECT_EQ(node::Environment::GetCurrent(isolate_), nullptr);
v8::Context::Scope context_scope(context);
EXPECT_EQ(node::Environment::GetCurrent(context), nullptr);
EXPECT_EQ(node::GetCurrentEnvironment(context), nullptr);
EXPECT_EQ(node::Environment::GetCurrent(isolate_), nullptr);
}
TEST_F(EnvironmentTest, NonNodeJSContext) {
const v8::HandleScope handle_scope(isolate_);
const Argv argv;
Env test_env {handle_scope, argv};
EXPECT_EQ(node::Environment::GetCurrent(v8::Local<v8::Context>()), nullptr);
node::Environment* env = *test_env;
EXPECT_EQ(node::Environment::GetCurrent(isolate_), env);
EXPECT_EQ(node::Environment::GetCurrent(env->context()), env);
EXPECT_EQ(node::GetCurrentEnvironment(env->context()), env);
v8::Local<v8::Context> context = v8::Context::New(isolate_);
EXPECT_EQ(node::Environment::GetCurrent(context), nullptr);
EXPECT_EQ(node::GetCurrentEnvironment(context), nullptr);
EXPECT_EQ(node::Environment::GetCurrent(isolate_), env);
v8::Context::Scope context_scope(context);
EXPECT_EQ(node::Environment::GetCurrent(context), nullptr);
EXPECT_EQ(node::GetCurrentEnvironment(context), nullptr);
EXPECT_EQ(node::Environment::GetCurrent(isolate_), nullptr);
}
static void at_exit_callback1(void* arg) {
called_cb_1 = true;
if (arg) {
cb_1_arg = *static_cast<std::string*>(arg);
}
}
static void at_exit_callback2(void* arg) {
called_cb_2 = true;
}
static void at_exit_callback_ordered1(void* arg) {
EXPECT_TRUE(called_cb_ordered_2);
called_cb_ordered_1 = true;
}
static void at_exit_callback_ordered2(void* arg) {
EXPECT_FALSE(called_cb_ordered_1);
called_cb_ordered_2 = true;
}
static void at_exit_js(void* arg) {
v8::Isolate* isolate = static_cast<v8::Isolate*>(arg);
v8::HandleScope handle_scope(isolate);
v8::Local<v8::Object> obj = v8::Object::New(isolate);
EXPECT_FALSE(obj.IsEmpty()); // Assert VM is still alive.
EXPECT_TRUE(obj->IsObject());
called_at_exit_js = true;
}
// Reproduces the sequence node::ObjectWrap performs since
// https://github.com/nodejs/node/pull/63642, without using ObjectWrap
// itself: the hook removes its own environment cleanup hook. When that runs
// while the cleanup queue is being drained, CleanupHookThunkRun() must not
// read the CleanupHookThunk after invoking the hook -- the hook has already
// erased and freed it. See https://github.com/nodejs/node/issues/65195.
static void self_removing_cleanup_hook(void* arg) {
auto* state = static_cast<SelfRemovingCleanupHookState*>(arg);
state->ran = true;
node::RemoveEnvironmentCleanupHook(
state->isolate, self_removing_cleanup_hook, state);
}
TEST_F(EnvironmentTest, SetImmediateCleanup) {
int called = 0;
int called_unref = 0;
{
const v8::HandleScope handle_scope(isolate_);
const Argv argv;
Env env {handle_scope, argv};
node::LoadEnvironment(*env,
[&](const node::StartExecutionCallbackInfo& info)
-> v8::MaybeLocal<v8::Value> {
return v8::Object::New(isolate_);
});
(*env)->SetImmediate([&](node::Environment* env_arg) {
EXPECT_EQ(env_arg, *env);
called++;
}, node::CallbackFlags::kRefed);
(*env)->SetImmediate([&](node::Environment* env_arg) {
EXPECT_EQ(env_arg, *env);
called_unref++;
}, node::CallbackFlags::kUnrefed);
}
EXPECT_EQ(called, 1);
EXPECT_EQ(called_unref, 0);
}
TEST_F(EnvironmentTest, RunAndClearNativeImmediatesSkipsEmptyScope) {
const v8::HandleScope handle_scope(isolate_);
const Argv argv;
Env env{handle_scope, argv};
v8::Local<v8::Context> context = env.context();
using IntVec = std::vector<int>;
IntVec callback_calls;
v8::Local<v8::Function> must_call =
v8::Function::New(
context,
[](const v8::FunctionCallbackInfo<v8::Value>& info) {
IntVec* callback_calls =
static_cast<IntVec*>(info.Data().As<v8::External>()->Value(
v8::kExternalPointerTypeTagDefault));
callback_calls->push_back(info[0].As<v8::Int32>()->Value());
},
v8::External::New(isolate_,
static_cast<void*>(&callback_calls),
v8::kExternalPointerTypeTagDefault))
.ToLocalChecked();
context->Global()
->Set(context,
v8::String::NewFromUtf8Literal(isolate_, "mustCall"),
must_call)
.Check();
v8::Local<v8::Function> eval_in_env =
node::LoadEnvironment(*env, "return eval;")
.ToLocalChecked()
.As<v8::Function>();
v8::Local<v8::Value> queue_microtask = v8::String::NewFromUtf8Literal(
isolate_, "Promise.resolve().then(() => mustCall(1));");
eval_in_env->Call(context, v8::Null(isolate_), 1, &queue_microtask)
.ToLocalChecked();
EXPECT_TRUE(callback_calls.empty());
(*env)->RunAndClearNativeImmediates();
EXPECT_TRUE(callback_calls.empty());
context->GetMicrotaskQueue()->PerformCheckpoint(isolate_);
EXPECT_EQ(callback_calls, (IntVec{1}));
callback_calls.clear();
queue_microtask = v8::String::NewFromUtf8Literal(
isolate_, "Promise.resolve().then(() => mustCall(2));");
eval_in_env->Call(context, v8::Null(isolate_), 1, &queue_microtask)
.ToLocalChecked();
EXPECT_TRUE(callback_calls.empty());
bool native_immediate_called = false;
(*env)->SetImmediate(
[&](node::Environment* env_arg) {
EXPECT_EQ(env_arg, *env);
native_immediate_called = true;
},
node::CallbackFlags::kRefed);
(*env)->RunAndClearNativeImmediates();
EXPECT_TRUE(native_immediate_called);
EXPECT_EQ(callback_calls, (IntVec{2}));
}
static char hello[] = "hello";
TEST_F(EnvironmentTest, BufferWithFreeCallbackIsDetached) {
// Test that a Buffer allocated with a free callback is detached after
// its callback has been called.
const v8::HandleScope handle_scope(isolate_);
const Argv argv;
int callback_calls = 0;
v8::Local<v8::ArrayBuffer> ab;
{
Env env {handle_scope, argv};
v8::Local<v8::Object> buf_obj = node::Buffer::New(
isolate_,
hello,
sizeof(hello),
[](char* data, void* hint) {
CHECK_EQ(data, hello);
++*static_cast<int*>(hint);
},
&callback_calls).ToLocalChecked();
CHECK(buf_obj->IsUint8Array());
ab = buf_obj.As<v8::Uint8Array>()->Buffer();
CHECK_EQ(ab->ByteLength(), sizeof(hello));
}
CHECK_EQ(callback_calls, 1);
#ifdef V8_ENABLE_SANDBOX
CHECK_EQ(ab->ByteLength(), sizeof(hello));
#else
CHECK_EQ(ab->ByteLength(), 0);
#endif
}
#if HAVE_INSPECTOR
TEST_F(EnvironmentTest, InspectorMultipleEmbeddedEnvironments) {
// Tests that child Environments can be created through the public API
// that are accessible by the inspector.
// This test sets a global variable in the child Environment, and reads it
// back both through the inspector and inside the child Environment, and
// makes sure that those correspond to the value that was originally set.
v8::Locker locker(isolate_);
const v8::HandleScope handle_scope(isolate_);
const Argv argv;
Env env {handle_scope, argv};
v8::Local<v8::Context> context = isolate_->GetCurrentContext();
node::LoadEnvironment(*env,
"'use strict';\n"
"const { Worker } = require('worker_threads');\n"
"const { Session } = require('inspector');\n"
"const session = new Session();\n"
"session.connect();\n"
"session.on('NodeWorker.attachedToWorker', (\n"
" ({ params: { workerInfo, sessionId } }) => {\n"
" session.post('NodeWorker.sendMessageToWorker', {\n"
" sessionId,\n"
" message: JSON.stringify({\n"
" id: 1,\n"
" method: 'Runtime.evaluate',\n"
" params: {\n"
" expression: 'globalThis.variableFromParent = 42;'\n"
" }\n"
" })\n"
" });\n"
" session.on('NodeWorker.receivedMessageFromWorker',\n"
" ({ params: { message } }) => {\n"
" global.messageFromWorker = \n"
" JSON.parse(message).result.result.value;\n"
" });\n"
" }));\n"
"session.post('NodeWorker.enable', { waitForDebuggerOnStart: false });\n")
.ToLocalChecked();
struct ChildEnvironmentData {
node::ThreadId thread_id;
std::unique_ptr<node::InspectorParentHandle> inspector_parent_handle;
node::MultiIsolatePlatform* platform;
int32_t extracted_value = -1;
uv_async_t thread_stopped_async;
};
ChildEnvironmentData data;
data.thread_id = node::AllocateEnvironmentThreadId();
data.inspector_parent_handle =
GetInspectorParentHandle(*env, data.thread_id, "file:///embedded.js");
CHECK(data.inspector_parent_handle);
data.platform = GetMultiIsolatePlatform(*env);
CHECK_NOT_NULL(data.platform);
bool thread_stopped = false;
int err = uv_async_init(
¤t_loop, &data.thread_stopped_async, [](uv_async_t* async) {
*static_cast<bool*>(async->data) = true;
uv_close(reinterpret_cast<uv_handle_t*>(async), nullptr);
});
CHECK_EQ(err, 0);
data.thread_stopped_async.data = &thread_stopped;
uv_thread_t thread;
err = uv_thread_create(&thread, [](void* arg) {
ChildEnvironmentData* data = static_cast<ChildEnvironmentData*>(arg);
std::shared_ptr<node::ArrayBufferAllocator> aba =
node::ArrayBufferAllocator::Create();
uv_loop_t loop;
uv_loop_init(&loop);
v8::Isolate* isolate = NewIsolate(aba, &loop, data->platform);
CHECK_NOT_NULL(isolate);
{
v8::Locker locker(isolate);
v8::Isolate::Scope isolate_scope(isolate);
v8::HandleScope handle_scope(isolate);
v8::Local<v8::Context> context = node::NewContext(isolate);
CHECK(!context.IsEmpty());
v8::Context::Scope context_scope(context);
node::IsolateData* isolate_data = node::CreateIsolateData(
isolate,
&loop,
data->platform);
CHECK_NOT_NULL(isolate_data);
node::Environment* environment = node::CreateEnvironment(
isolate_data,
context,
{ "dummy" },
{},
node::EnvironmentFlags::kNoFlags,
data->thread_id,
std::move(data->inspector_parent_handle));
CHECK_NOT_NULL(environment);
v8::Local<v8::Value> extracted_value = LoadEnvironment(
environment,
"while (!global.variableFromParent) {}\n"
"return global.variableFromParent;").ToLocalChecked();
uv_run(&loop, UV_RUN_DEFAULT);
CHECK(extracted_value->IsInt32());
data->extracted_value = extracted_value.As<v8::Int32>()->Value();
node::FreeEnvironment(environment);
node::FreeIsolateData(isolate_data);
}
data->platform->DisposeIsolate(isolate);
uv_run(&loop, UV_RUN_DEFAULT);
CHECK_EQ(uv_loop_close(&loop), 0);
uv_async_send(&data->thread_stopped_async);
}, &data);
CHECK_EQ(err, 0);
bool more;
do {
uv_run(¤t_loop, UV_RUN_DEFAULT);
data.platform->DrainTasks(isolate_);
more = uv_loop_alive(¤t_loop);
} while (!thread_stopped || more);
uv_thread_join(&thread);
v8::Local<v8::Value> from_inspector =
context->Global()->Get(
context,
v8::String::NewFromOneByte(
isolate_,
reinterpret_cast<const uint8_t*>("messageFromWorker"))
.ToLocalChecked())
.ToLocalChecked();
CHECK_EQ(data.extracted_value, 42);
CHECK_EQ(from_inspector->IntegerValue(context).FromJust(), 42);
}
TEST_F(EnvironmentTest, InspectorWithoutPlatform) {
const v8::HandleScope handle_scope(isolate_);
const Argv argv;
node::IsolateData* isolate_data = node::CreateIsolateData(
isolate_, &NodeTestFixture::current_loop, nullptr);
v8::Local<v8::Context> context = node::NewContext(isolate_);
v8::Context::Scope context_scope(context);
std::vector<std::string> args(*argv, *argv + 1);
node::Environment* env =
node::CreateEnvironment(isolate_data, context, args, args);
CHECK_NOT_NULL(env);
v8::Local<v8::Value> result =
node::LoadEnvironment(env,
"const { Session } = require('inspector');\n"
"const session = new Session();\n"
"session.connect();\n"
"console.time('t'); console.timeEnd('t');\n"
"session.disconnect();\n"
"return 42;")
.ToLocalChecked();
EXPECT_EQ(result->Int32Value(context).FromJust(), 42);
node::FreeEnvironment(env);
node::FreeIsolateData(isolate_data);
}
#endif // HAVE_INSPECTOR
TEST_F(EnvironmentTest, ExitHandlerTest) {
const v8::HandleScope handle_scope(isolate_);
const Argv argv;
int callback_calls = 0;
Env env {handle_scope, argv};
SetProcessExitHandler(*env, [&](node::Environment* env_, int exit_code) {
EXPECT_EQ(*env, env_);
EXPECT_EQ(exit_code, 42);
callback_calls++;
node::Stop(*env);
});
// When terminating, v8 throws makes the current embedder call bail out
// with MaybeLocal<>()
EXPECT_TRUE(node::LoadEnvironment(*env, "process.exit(42)").IsEmpty());
EXPECT_EQ(callback_calls, 1);
}
TEST_F(EnvironmentTest, SetImmediateMicrotasks) {
int called = 0;
{
const v8::HandleScope handle_scope(isolate_);
const Argv argv;
Env env {handle_scope, argv};
node::LoadEnvironment(*env,
[&](const node::StartExecutionCallbackInfo& info)
-> v8::MaybeLocal<v8::Value> {
return v8::Object::New(isolate_);
});
(*env)->SetImmediate([&](node::Environment* env_arg) {
EXPECT_EQ(env_arg, *env);
isolate_->EnqueueMicrotask([](void* arg) {
++*static_cast<int*>(arg);
}, &called);
}, node::CallbackFlags::kRefed);
uv_run(¤t_loop, UV_RUN_DEFAULT);
}
EXPECT_EQ(called, 1);
}
#ifndef _WIN32 // No SIGINT on Windows.
TEST_F(NodeZeroIsolateTestFixture, CtrlCWithOnlySafeTerminationTest) {
// Allocate and initialize Isolate.
v8::Isolate::CreateParams create_params;
create_params.array_buffer_allocator = allocator.get();
create_params.cpp_heap =
v8::CppHeap::Create(platform.get(), v8::CppHeapCreateParams{{}})
.release();
v8::Isolate* isolate = v8::Isolate::Allocate();
CHECK_NOT_NULL(isolate);
platform->RegisterIsolate(isolate, ¤t_loop);
v8::Isolate::Initialize(isolate, create_params);
// Try creating Context + IsolateData + Environment.
{
v8::Locker locker(isolate);
v8::Isolate::Scope isolate_scope(isolate);
v8::HandleScope handle_scope(isolate);
auto context = node::NewContext(isolate);
CHECK(!context.IsEmpty());
v8::Context::Scope context_scope(context);
std::unique_ptr<node::IsolateData, decltype(&node::FreeIsolateData)>
isolate_data{node::CreateIsolateData(isolate,
¤t_loop,
platform.get()),
node::FreeIsolateData};
CHECK(isolate_data);
std::unique_ptr<node::Environment, decltype(&node::FreeEnvironment)>
environment{node::CreateEnvironment(isolate_data.get(),
context,
{},
{}),
node::FreeEnvironment};
CHECK(environment);
EXPECT_EQ(node::GetEnvironmentIsolateData(environment.get()),
isolate_data.get());
EXPECT_EQ(node::GetArrayBufferAllocator(isolate_data.get()), nullptr);
v8::Local<v8::Value> main_ret =
node::LoadEnvironment(environment.get(),
"'use strict';\n"
"const { runInThisContext } = require('vm');\n"
"try {\n"
" runInThisContext("
" `process.kill(process.pid, 'SIGINT'); while(true){}`, "
" { breakOnSigint: true });\n"
" return 'unreachable';\n"
"} catch (err) {\n"
" return err.code;\n"
"}").ToLocalChecked();
node::Utf8Value main_ret_str(isolate, main_ret);
EXPECT_EQ(std::string(*main_ret_str), "ERR_SCRIPT_EXECUTION_INTERRUPTED");
}
// Cleanup.
platform->DisposeIsolate(isolate);
}
#endif // _WIN32
TEST_F(EnvironmentTest, NestedMicrotaskQueue) {
const v8::HandleScope handle_scope(isolate_);
const Argv argv;
v8::MicrotaskQueue* queue =
v8::MicrotaskQueue::New(isolate_, v8::MicrotasksPolicy::kExplicit);
v8::Local<v8::Context> context =
v8::Context::New(isolate_,
nullptr,
{},
{},
v8::DeserializeInternalFieldsCallback(),
queue);
node::InitializeContext(context);
v8::Context::Scope context_scope(context);
using IntVec = std::vector<int>;
IntVec callback_calls;
v8::Local<v8::Function> must_call =
v8::Function::New(
context,
[](const v8::FunctionCallbackInfo<v8::Value>& info) {
IntVec* callback_calls =
static_cast<IntVec*>(info.Data().As<v8::External>()->Value(
v8::kExternalPointerTypeTagDefault));
callback_calls->push_back(info[0].As<v8::Int32>()->Value());
},
v8::External::New(isolate_,
static_cast<void*>(&callback_calls),
v8::kExternalPointerTypeTagDefault))
.ToLocalChecked();
context->Global()->Set(
context,
v8::String::NewFromUtf8Literal(isolate_, "mustCall"),
must_call).Check();
node::Environment* env =
node::CreateEnvironment(isolate_data_, context, {}, {});
CHECK_NE(nullptr, env);
v8::Local<v8::Function> eval_in_env = node::LoadEnvironment(
env,
"mustCall(1);\n"
"Promise.resolve().then(() => mustCall(2));\n"
"require('vm').runInNewContext("
" 'Promise.resolve().then(() => mustCall(3))',"
" { mustCall },"
" { microtaskMode: 'afterEvaluate' }"
");\n"
"require('vm').runInNewContext("
" 'Promise.resolve().then(() => mustCall(4))',"
" { mustCall }"
");\n"
"setTimeout(() => {"
" Promise.resolve().then(() => mustCall(5));"
"}, 10);\n"
"mustCall(6);\n"
"return eval;\n").ToLocalChecked().As<v8::Function>();
EXPECT_EQ(callback_calls, (IntVec { 1, 3, 6, 2, 4 }));
v8::Local<v8::Value> queue_microtask_code = v8::String::NewFromUtf8Literal(
isolate_, "queueMicrotask(() => mustCall(7));");
eval_in_env->Call(context,
v8::Null(isolate_),
1,
&queue_microtask_code).ToLocalChecked();
EXPECT_EQ(callback_calls, (IntVec { 1, 3, 6, 2, 4 }));
isolate_->PerformMicrotaskCheckpoint();
EXPECT_EQ(callback_calls, (IntVec { 1, 3, 6, 2, 4 }));
queue->PerformCheckpoint(isolate_);
EXPECT_EQ(callback_calls, (IntVec { 1, 3, 6, 2, 4, 7 }));
int exit_code = SpinEventLoop(env).FromJust();
EXPECT_EQ(exit_code, 0);
EXPECT_EQ(callback_calls, (IntVec { 1, 3, 6, 2, 4, 7, 5 }));
node::FreeEnvironment(env);
}
static bool interrupted = false;
static void OnInterrupt(void* arg) {
interrupted = true;
}
TEST_F(EnvironmentTest, RequestInterruptAtExit) {
const v8::HandleScope handle_scope(isolate_);
const Argv argv;
Local<Context> context = node::NewContext(isolate_);
CHECK(!context.IsEmpty());
context->Enter();
std::vector<std::string> args(*argv, *argv + 1);
std::vector<std::string> exec_args(*argv, *argv + 1);
node::Environment* environment =
node::CreateEnvironment(isolate_data_, context, args, exec_args);
CHECK_NE(nullptr, environment);
node::RequestInterrupt(environment, OnInterrupt, nullptr);
node::FreeEnvironment(environment);
EXPECT_TRUE(interrupted);
context->Exit();
}
TEST_F(EnvironmentTest, EmbedderBuiltinCodeCache) {
v8::HandleScope handle_scope(isolate_);
v8::Local<v8::Context> context = node::NewContext(isolate_);
v8::Context::Scope context_scope(context);
std::vector<node::EmbedderBuiltinCodeCache::Entry> entries =
node::EmbedderBuiltinCodeCache::Generate(context);
ASSERT_GT(entries.size(), 100u);
{
node::EmbedderBuiltinCodeCache cache(std::move(entries));
EXPECT_EQ(node::SetBuiltinCodeCache(isolate_data_, &cache),
v8::ScriptCompiler::CachedData::kSuccess);
}
std::unique_ptr<node::Environment, decltype(&node::FreeEnvironment)> env(
node::CreateEnvironment(isolate_data_, context, {}, {}),
node::FreeEnvironment);
node::Realm* realm = env->principal_realm();
EXPECT_EQ(realm->builtins_with_cache.count("internal/bootstrap/node"), 1u);
for (const std::string& id : realm->builtins_without_cache) {
EXPECT_EQ(id.rfind("internal/per_context/", 0), 0u) << id;
}
uint8_t* bytes = new uint8_t[64]();
std::vector<node::EmbedderBuiltinCodeCache::Entry> bad;
bad.push_back({"internal/bootstrap/node",
std::make_unique<v8::ScriptCompiler::CachedData>(
bytes, 64, v8::ScriptCompiler::CachedData::BufferOwned)});
node::EmbedderBuiltinCodeCache bad_cache(std::move(bad));
EXPECT_NE(node::SetBuiltinCodeCache(isolate_data_, &bad_cache),
v8::ScriptCompiler::CachedData::kSuccess);
EXPECT_FALSE(isolate_data_->builtin_code_cache().empty());
node::SetBuiltinCodeCache(isolate_data_, nullptr);
EXPECT_TRUE(isolate_data_->builtin_code_cache().empty());
}
TEST_F(EnvironmentTest, EmbedderPreload) {
v8::HandleScope handle_scope(isolate_);
v8::Local<v8::Context> context = node::NewContext(isolate_);
v8::Context::Scope context_scope(context);
node::EmbedderPreloadCallback preload = [](node::Environment* env,
v8::Local<v8::Value> process,
v8::Local<v8::Value> require) {
CHECK(process->IsObject());
CHECK(require->IsFunction());
process.As<v8::Object>()
->Set(env->context(),
v8::String::NewFromUtf8Literal(env->isolate(), "prop"),
v8::String::NewFromUtf8Literal(env->isolate(), "preload"))
.Check();
};
std::unique_ptr<node::Environment, decltype(&node::FreeEnvironment)> env(
node::CreateEnvironment(isolate_data_, context, {}, {}),
node::FreeEnvironment);
v8::Local<v8::Value> main_ret =
node::LoadEnvironment(env.get(), "return process.prop;", preload)
.ToLocalChecked();
node::Utf8Value main_ret_str(isolate_, main_ret);
EXPECT_EQ(std::string(*main_ret_str), "preload");
}
TEST_F(EnvironmentTest, LoadEnvironmentWithESModule) {
const v8::HandleScope handle_scope(isolate_);
const Argv argv;
Env env{handle_scope, argv};
node::ModuleData entry_point;
std::string source =
"import importedProcess from 'process';\n"
"export const process = importedProcess;\n"
"const stack = new Error().stack.split('\\n');\n"
"export const frame = stack.filter(line => /at /.test(line))[0];\n";
entry_point.set_source(source);
entry_point.set_format(node::ModuleFormat::kModule);
entry_point.set_resource_name("embedded:esm.mjs");
v8::Local<v8::Value> result =
node::LoadEnvironment(*env, &entry_point).ToLocalChecked();
// The ESM entry point returns the module namespace object.
EXPECT_TRUE(result->IsObject());
v8::Local<v8::Context> context = isolate_->GetCurrentContext();
v8::Local<v8::String> process_str =
v8::String::NewFromUtf8Literal(isolate_, "process");
v8::Local<v8::Value> process_value =
result.As<v8::Object>()->Get(context, process_str).ToLocalChecked();
EXPECT_TRUE(process_value->IsObject());
v8::Local<v8::Value> global_process_value =
context->Global()->Get(context, process_str).ToLocalChecked();
EXPECT_TRUE(global_process_value->IsObject());
EXPECT_TRUE(process_value->StrictEquals(global_process_value));
v8::Local<v8::Value> frame_value =
result.As<v8::Object>()
->Get(context, v8::String::NewFromUtf8Literal(isolate_, "frame"))
.ToLocalChecked();
EXPECT_TRUE(frame_value->IsString());
node::Utf8Value frame_str(isolate_, frame_value);
printf("Frame: %s\n", *frame_str);
EXPECT_EQ(frame_str.ToString(), " at embedded:esm.mjs:3:15");
}
static const char* dynamic_import_source =
"const importedProcess = import('node:process');\n"
"const importedNonBuiltin = import('./non-existent.mjs');\n"
"importedNonBuiltin.catch((err) => \n"
" globalThis.importedNonBuiltinStack = err.stack)\n";
void CheckDynamicImportResult(v8::Isolate* isolate,
v8::Local<v8::Value> result) {
v8::Local<v8::Context> context = isolate->GetCurrentContext();
// Check the result of import('node:process').
EXPECT_TRUE(result->IsObject());
v8::Local<v8::Value> imported_process =
result.As<v8::Object>()
->Get(context,
v8::String::NewFromUtf8Literal(isolate, "importedProcess"))
.ToLocalChecked();
EXPECT_TRUE(imported_process->IsPromise());
EXPECT_EQ(imported_process.As<v8::Promise>()->State(),
v8::Promise::kFulfilled);
v8::Local<v8::Value> imported_value =
imported_process.As<v8::Promise>()->Result();
EXPECT_TRUE(imported_value->IsObject());
v8::Local<v8::Value> dynamic_process =
imported_value.As<v8::Object>()
->Get(context, v8::String::NewFromUtf8Literal(isolate, "default"))
.ToLocalChecked();
EXPECT_TRUE(dynamic_process->IsObject());
v8::Local<v8::Value> global_process_value =
context->Global()
->Get(context, v8::String::NewFromUtf8Literal(isolate, "process"))
.ToLocalChecked();
EXPECT_TRUE(global_process_value->IsObject());
EXPECT_TRUE(dynamic_process->StrictEquals(global_process_value));
// Check the result of import('./non-existent.mjs')
v8::Local<v8::Value> imported_non_builtin =
result.As<v8::Object>()
->Get(context,
v8::String::NewFromUtf8Literal(isolate, "importedNonBuiltin"))
.ToLocalChecked();
EXPECT_TRUE(imported_non_builtin->IsPromise());
EXPECT_EQ(imported_non_builtin.As<v8::Promise>()->State(),
v8::Promise::kRejected);
// Check the error message
v8::Local<v8::Value> imported_non_builtin_stack =
context->Global()
->Get(context,
v8::String::NewFromUtf8Literal(isolate,
"importedNonBuiltinStack"))
.ToLocalChecked();
EXPECT_TRUE(imported_non_builtin_stack->IsString());
node::Utf8Value error_str(isolate, imported_non_builtin_stack);
// Error stack should include "ERR_UNKNOWN_BUILTIN_MODULE"
EXPECT_NE(error_str.ToString().find("ERR_UNKNOWN_BUILTIN_MODULE"),
std::string::npos);
// Error stack should include "No such built-in module: ./non-existent.mjs"
EXPECT_NE(
error_str.ToString().find("No such built-in module: ./non-existent.mjs"),
std::string::npos);
}
TEST_F(EnvironmentTest, LoadEnvironmentWithESModuleDynamicImport) {
const v8::HandleScope handle_scope(isolate_);
const Argv argv;
Env env{handle_scope, argv};
// Test dynamic import('node:process') in entry point.
std::string source = std::string(dynamic_import_source) +
"export { importedProcess, importedNonBuiltin };\n";
node::ModuleData entry_point;
entry_point.set_source(source);
entry_point.set_format(node::ModuleFormat::kModule);
entry_point.set_resource_name("embedded:dynamic-import.mjs");
v8::Local<v8::Value> result =
node::LoadEnvironment(*env, &entry_point).ToLocalChecked();
// Finish the await.
v8::Local<v8::Context> context = isolate_->GetCurrentContext();
context->GetMicrotaskQueue()->PerformCheckpoint(isolate_);
CheckDynamicImportResult(isolate_, result);
}
TEST_F(EnvironmentTest, LoadEnvironmentWithCommonJSDynamicImport) {
const v8::HandleScope handle_scope(isolate_);
const Argv argv;
Env env{handle_scope, argv};
std::string source = std::string(dynamic_import_source) +
"return { importedProcess, importedNonBuiltin };\n";
node::ModuleData entry_point;
entry_point.set_source(source);
entry_point.set_format(node::ModuleFormat::kCommonJS);
entry_point.set_resource_name("/test-cjs-dynamic-import.js");
v8::Local<v8::Value> result =
node::LoadEnvironment(*env, &entry_point).ToLocalChecked();
// Finish the await.
v8::Local<v8::Context> context = isolate_->GetCurrentContext();
context->GetMicrotaskQueue()->PerformCheckpoint(isolate_);
CheckDynamicImportResult(isolate_, result);
}
TEST_F(EnvironmentTest, LoadEnvironmentWithESModuleImportMeta) {
const v8::HandleScope handle_scope(isolate_);
const Argv argv;
Env env{handle_scope, argv};
node::ModuleData entry_point;
// Test import.meta properties in ESM entry point.
std::string source = "export const url = import.meta.url;\n"
"export const main = import.meta.main;\n"
"export const filename = import.meta.filename;\n"
"export const dirname = import.meta.dirname;\n";
std::string exec_path = (*env)->exec_path();
std::string url = node::url::FromFilePath(exec_path);
entry_point.set_source(source);
entry_point.set_format(node::ModuleFormat::kModule);
entry_point.set_resource_name(url);
v8::Local<v8::Value> result =
node::LoadEnvironment(*env, &entry_point).ToLocalChecked();
EXPECT_TRUE(result->IsObject());
v8::Local<v8::Context> context = isolate_->GetCurrentContext();
// Check import.meta.url
v8::Local<v8::Value> url_value =
result.As<v8::Object>()
->Get(context, v8::String::NewFromUtf8Literal(isolate_, "url"))
.ToLocalChecked();
EXPECT_TRUE(url_value->IsString());
node::Utf8Value url_str(isolate_, url_value);
EXPECT_EQ(url_str.ToStringView(), url);
// Check import.meta.main
v8::Local<v8::Value> main_value =
result.As<v8::Object>()
->Get(context, v8::String::NewFromUtf8Literal(isolate_, "main"))
.ToLocalChecked();
EXPECT_TRUE(main_value->IsBoolean());
EXPECT_TRUE(main_value->BooleanValue(isolate_));
// Check import.meta.filename
v8::Local<v8::Value> filename_value =
result.As<v8::Object>()
->Get(context, v8::String::NewFromUtf8Literal(isolate_, "filename"))
.ToLocalChecked();
EXPECT_TRUE(filename_value->IsString());
node::Utf8Value filename_str(isolate_, filename_value);
EXPECT_EQ(filename_str.ToStringView(), exec_path);
// Check import.meta.dirname
v8::Local<v8::Value> dirname_value =
result.As<v8::Object>()
->Get(context, v8::String::NewFromUtf8Literal(isolate_, "dirname"))
.ToLocalChecked();
EXPECT_TRUE(dirname_value->IsString());
node::Utf8Value dirname_str(isolate_, dirname_value);
// Just check that dirname is a substring of exec_path
EXPECT_NE(exec_path.find(dirname_str.ToStringView()), std::string::npos);
}
TEST_F(EnvironmentTest, LoadEnvironmentWithCallbackWithCommonJSModule) {
const v8::HandleScope handle_scope(isolate_);
const Argv argv;
Env env{handle_scope, argv};
v8::Local<v8::Context> context = isolate_->GetCurrentContext();
v8::MaybeLocal<v8::Value> maybe = node::LoadEnvironment(
*env,
[&](const node::StartExecutionCallbackInfoWithModule& info)
-> v8::MaybeLocal<v8::Value> {
EXPECT_NE(nullptr, info.env());
EXPECT_TRUE(info.process_object()->IsObject());
EXPECT_TRUE(info.native_require()->IsFunction());
EXPECT_TRUE(info.run_module()->IsFunction());
// require("process") === process
v8::Local<v8::String> process_str =
v8::String::NewFromUtf8Literal(isolate_, "process");
v8::Local<v8::Value> require_args[] = {process_str};
v8::Local<v8::Value> required_process =
info.native_require()
->Call(context, v8::Null(isolate_), 1, require_args)
.ToLocalChecked();
EXPECT_TRUE(required_process->IsObject());
EXPECT_TRUE(required_process->StrictEquals(info.process_object()));
// Test running a CJS entry point via run_module.
v8::Local<v8::Value> cjs_source = v8::String::NewFromUtf8Literal(
isolate_,
"globalThis.processInModule = require('process');\n"
"const stack = new Error().stack.split('\\n');\n"
"globalThis.frame = stack.filter(line => /at /.test(line))[0];\n"
"return 42;\n");
v8::Local<v8::Value> format = v8::Integer::New(
isolate_, static_cast<int32_t>(node::ModuleFormat::kCommonJS));
v8::Local<v8::Value> resource_name =
v8::String::NewFromUtf8Literal(isolate_, "/test-cjs.js");
v8::Local<v8::Value> args[] = {cjs_source, format, resource_name};
v8::Local<v8::Value> result =
info.run_module()
->Call(context, v8::Null(isolate_), 3, args)
.ToLocalChecked();
EXPECT_TRUE(result->IsUint32());
EXPECT_EQ(result.As<v8::Uint32>()->Value(), static_cast<uint32_t>(42));
v8::Local<v8::Value> process_in_module =
context->Global()
->Get(
context,
v8::String::NewFromUtf8Literal(isolate_, "processInModule"))
.ToLocalChecked();
EXPECT_TRUE(process_in_module->IsObject());
EXPECT_TRUE(process_in_module->StrictEquals(info.process_object()));
return result;
},
nullptr);
EXPECT_TRUE(!maybe.IsEmpty());
v8::Local<v8::Value> frame_value =
context->Global()
->Get(context, v8::String::NewFromUtf8Literal(isolate_, "frame"))
.ToLocalChecked();
EXPECT_TRUE(frame_value->IsString());
node::Utf8Value frame_str(isolate_, frame_value);
printf("Frame: %s\n", *frame_str);
EXPECT_EQ(frame_str.ToString(), " at /test-cjs.js:2:15");
}
TEST_F(EnvironmentTest, LoadEnvironmentWithCallbackWithESModule) {
const v8::HandleScope handle_scope(isolate_);
const Argv argv;
Env env{handle_scope, argv};
v8::Local<v8::Context> context = isolate_->GetCurrentContext();
v8::MaybeLocal<v8::Value> maybe = node::LoadEnvironment(
*env,
[&](const node::StartExecutionCallbackInfoWithModule& info)
-> v8::MaybeLocal<v8::Value> {
// Test running an ESM entry point via run_module.
v8::Local<v8::Value> source_str = v8::String::NewFromUtf8Literal(
isolate_,
"import importedProcess from 'process';\n"
"export const process = importedProcess;\n"
"const stack = new Error().stack.split('\\n');\n"
"export const frame = stack.filter(line => /at "
"/.test(line))[0];\n");
v8::Local<v8::Value> format = v8::Integer::New(
isolate_, static_cast<int32_t>(node::ModuleFormat::kModule));
v8::Local<v8::Value> resource_name =
v8::String::NewFromUtf8Literal(isolate_, "embedded:esm.mjs");
v8::Local<v8::Value> args[] = {source_str, format, resource_name};
return info.run_module()->Call(context, v8::Null(isolate_), 3, args);
},
nullptr);
v8::Local<v8::Value> result = maybe.ToLocalChecked();
v8::Local<v8::String> process_str =
v8::String::NewFromUtf8Literal(isolate_, "process");
// The ESM entry point returns the module namespace object.
EXPECT_TRUE(result->IsObject());
v8::Local<v8::Value> process_value =
result.As<v8::Object>()->Get(context, process_str).ToLocalChecked();
EXPECT_TRUE(process_value->IsObject());
v8::Local<v8::Value> global_process_value =
context->Global()->Get(context, process_str).ToLocalChecked();
EXPECT_TRUE(global_process_value->IsObject());
EXPECT_TRUE(process_value->StrictEquals(global_process_value));
v8::Local<v8::Value> frame_value =
result.As<v8::Object>()
->Get(context, v8::String::NewFromUtf8Literal(isolate_, "frame"))
.ToLocalChecked();
EXPECT_TRUE(frame_value->IsString());
node::Utf8Value frame_str(isolate_, frame_value);
printf("Frame: %s\n", *frame_str);
EXPECT_EQ(frame_str.ToString(), " at embedded:esm.mjs:3:15");
}
namespace {
void CustomAbortHandlerForContractTest(const char* location,
const char* message) {}
bool abort_handler_dispatch_flag = false;
const char* abort_handler_received_location = nullptr;
const char* abort_handler_received_message = nullptr;
void AbortHandlerThatSetsDispatchFlag(const char* location,
const char* message) {
abort_handler_dispatch_flag = true;
abort_handler_received_location = location;
abort_handler_received_message = message;
}
} // namespace
TEST(AbortHandlerTest, DefaultIsNonNullAndSetAbortHandlerRoundTrips) {
node::AbortHandler old = node::GetAbortHandler();
// There should always be a non-null default handler installed.
EXPECT_NE(node::GetAbortHandler(), nullptr);
node::SetAbortHandler(CustomAbortHandlerForContractTest);
EXPECT_EQ(node::GetAbortHandler(), CustomAbortHandlerForContractTest);
node::SetAbortHandler(nullptr);
EXPECT_NE(node::GetAbortHandler(), nullptr);
EXPECT_NE(node::GetAbortHandler(), CustomAbortHandlerForContractTest);
node::SetAbortHandler(old);
}
TEST(AbortHandlerTest, InstalledHandlerIsInvokedWhenCalled) {
node::AbortHandler old = node::GetAbortHandler();
abort_handler_dispatch_flag = false;
abort_handler_received_location = nullptr;
abort_handler_received_message = nullptr;
node::SetAbortHandler(AbortHandlerThatSetsDispatchFlag);
node::AbortHandler h = node::GetAbortHandler();
// Fail cleanly (instead of crashing on a null call) if the handler wasn't
// actually installed.
ASSERT_NE(h, nullptr);
// Dispatch through the public GetAbortHandler() accessor directly (not via
// the ABORT() macro, so nothing terminates), and verify the message is
// passed through unchanged.
node::GetAbortHandler()("some-test-location", "some-test-message");
EXPECT_TRUE(abort_handler_dispatch_flag);
EXPECT_STREQ(abort_handler_received_location, "some-test-location");
EXPECT_STREQ(abort_handler_received_message, "some-test-message");
node::SetAbortHandler(old);
}