mirror of
https://github.com/komari-monitor/komari.git
synced 2026-11-17 12:10:56 +00:00
Add StorageDir (data/plugin-data/<short>) exposed to plugin runtimes as __storageDir__, giving plugins a location for long-term data that survives plugin updates. The existing DataDir/<short> remains the install/code directory and is replaced on update, while storage is preserved and only removed when the plugin is deleted. Update filesystem path handling to support plugin storage roots, reset StorageDir in tests, and drop the unused golang.org/x/image dependency.
938 lines
31 KiB
Go
938 lines
31 KiB
Go
package jsruntime
|
|
|
|
import (
|
|
"bytes"
|
|
"io"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"os"
|
|
"path/filepath"
|
|
"runtime"
|
|
"strings"
|
|
"sync/atomic"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func TestNodeCoreModulesAndECMAScriptBuiltins(t *testing.T) {
|
|
baseDir := t.TempDir()
|
|
runtime, err := New(`
|
|
async function verify() {
|
|
const fs = require("node:fs");
|
|
const path = require("path");
|
|
const os = require("os");
|
|
const EventEmitter = require("events");
|
|
fs.mkdirSync("data", { recursive: true });
|
|
fs.writeFileSync(path.join("data", "sync.txt"), "sync", "utf8");
|
|
await fs.promises.writeFile("data/async.txt", Buffer.from("async"));
|
|
const asyncText = await fs.promises.readFile("data/async.txt", "utf8");
|
|
const callbackText = await new Promise((resolve, reject) => fs.readFile("data/sync.txt", "utf8", (error, value) => error ? reject(error) : resolve(value)));
|
|
const entries = fs.readdirSync("data", { withFileTypes: true });
|
|
const stat = fs.statSync("data/sync.txt");
|
|
const emitter = new EventEmitter();
|
|
let eventValue = 0;
|
|
emitter.once("value", (value) => eventValue = value);
|
|
emitter.emit("value", 7);
|
|
const mapped = [1, 2, 3, 4].map((value) => value * 2).filter((value) => value > 4).reduce((sum, value) => sum + value, 0);
|
|
return asyncText === "async" && callbackText === "sync" && stat.isFile() && stat.size === 4 &&
|
|
entries.some((entry) => entry.name === "sync.txt" && entry.isFile()) &&
|
|
path.basename(path.join("a", "b.txt")) === "b.txt" && typeof os.platform() === "string" &&
|
|
process === require("process") && process.cwd() === __dirname && typeof process.nextTick === "function" &&
|
|
eventValue === 7 && mapped === 14 && JSON.parse(JSON.stringify({ ok: true })).ok && eval("2 + 3") === 5;
|
|
}
|
|
`, Options{NodeJS: true, BaseDir: baseDir, Console: io.Discard, Timeout: 3 * time.Second})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer runtime.Close()
|
|
|
|
if err := runtime.Call("verify"); err != nil {
|
|
t.Fatalf("Node core modules failed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestNodeFileAccessConfinementAndAllowAll(t *testing.T) {
|
|
root := t.TempDir()
|
|
baseDir := filepath.Join(root, "base")
|
|
if err := os.Mkdir(baseDir, 0o700); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
outside := filepath.Join(root, "outside.txt")
|
|
if err := os.WriteFile(outside, []byte("outside"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(root, "outside.js"), []byte(`module.exports = "outside module";`), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
confined, err := New(`
|
|
function verify() {
|
|
let fsDenied = false;
|
|
let requireDenied = false;
|
|
try { require("fs").readFileSync("../outside.txt", "utf8"); }
|
|
catch (error) { fsDenied = String(error).includes("escapes BaseDir"); }
|
|
try { require("../outside.js"); }
|
|
catch (error) { requireDenied = String(error).includes("escapes BaseDir"); }
|
|
return fsDenied && requireDenied;
|
|
}
|
|
`, Options{NodeJS: true, BaseDir: baseDir, Console: io.Discard, Timeout: time.Second})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := confined.Call("verify"); err != nil {
|
|
confined.Close()
|
|
t.Fatalf("confined fs access failed: %v", err)
|
|
}
|
|
confined.Close()
|
|
|
|
unrestricted, err := New(`
|
|
function verify() {
|
|
return require("fs").readFileSync("../outside.txt", "utf8") === "outside" &&
|
|
require("../outside.js") === "outside module";
|
|
}
|
|
`, Options{NodeJS: true, BaseDir: baseDir, AllowAllFileAccess: true, Console: io.Discard, Timeout: time.Second})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer unrestricted.Close()
|
|
if err := unrestricted.Call("verify"); err != nil {
|
|
t.Fatalf("AllowAllFileAccess failed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestStorageDirIsConfinedAdditionalRoot(t *testing.T) {
|
|
root := t.TempDir()
|
|
baseDir := filepath.Join(root, "base")
|
|
storageDir := filepath.Join(root, "plugin-data")
|
|
otherStorage := filepath.Join(root, "plugin-data-other")
|
|
for _, dir := range []string{baseDir, storageDir, otherStorage} {
|
|
if err := os.Mkdir(dir, 0o700); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
runtime, err := New(`
|
|
const fs = require("fs");
|
|
const path = require("path");
|
|
fs.writeFileSync(path.join(__storageDir__, "saved.txt"), "hello", "utf8");
|
|
async function verify() {
|
|
if (await fs.promises.readFile(path.join(__storageDir__, "saved.txt"), "utf8") !== "hello") {
|
|
return "storage data not readable";
|
|
}
|
|
if (typeof __storageDir__ !== "string" || __storageDir__.length === 0) {
|
|
return "__storageDir__ missing";
|
|
}
|
|
let wroteBase = false;
|
|
try { fs.writeFileSync("in-base.txt", "x"); wroteBase = true; } catch (error) {}
|
|
if (!wroteBase) {
|
|
return "BaseDir no longer writable";
|
|
}
|
|
let baseReachedStorage = false;
|
|
try { fs.readFileSync(path.join("..", path.basename(__storageDir__), "saved.txt"), "utf8"); }
|
|
catch (error) { baseReachedStorage = true; }
|
|
if (!baseReachedStorage) {
|
|
return "BaseDir reached the storage dir";
|
|
}
|
|
let escapedStorage = false;
|
|
try { fs.writeFileSync(path.join(__storageDir__, "..", "escaped.txt"), "x"); }
|
|
catch (error) { escapedStorage = true; }
|
|
if (!escapedStorage) {
|
|
return "escaped the storage dir";
|
|
}
|
|
let reachedOtherStorage = false;
|
|
try { fs.writeFileSync(path.join(__storageDir__, "..", "plugin-data-other", "x.txt"), "x"); }
|
|
catch (error) { reachedOtherStorage = true; }
|
|
if (!reachedOtherStorage) {
|
|
return "reached another plugin storage dir";
|
|
}
|
|
return true;
|
|
}
|
|
`, Options{NodeJS: true, BaseDir: baseDir, StorageDir: storageDir, Console: io.Discard, Timeout: 3 * time.Second})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer runtime.Close()
|
|
if err := runtime.Call("verify"); err != nil {
|
|
t.Fatalf("storage dir confinement failed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestNodeRequireUsesCurrentDirectoryAsImplicitBaseDir(t *testing.T) {
|
|
root := t.TempDir()
|
|
baseDir := filepath.Join(root, "base")
|
|
if err := os.Mkdir(baseDir, 0o700); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(root, "outside.js"), []byte(`module.exports = true;`), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Chdir(baseDir)
|
|
|
|
runtime, err := New(`
|
|
function verify() {
|
|
try { require("../outside.js"); return false; }
|
|
catch (error) { return String(error).includes("escapes BaseDir"); }
|
|
}
|
|
`, Options{NodeJS: true, Console: io.Discard, Timeout: time.Second})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer runtime.Close()
|
|
if err := runtime.Call("verify"); err != nil {
|
|
t.Fatalf("implicit Node.js BaseDir confinement failed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestProcessExitZeroIsNormalTermination(t *testing.T) {
|
|
baseDir := t.TempDir()
|
|
newRuntime := func(script string) *Runtime {
|
|
t.Helper()
|
|
runtime, err := New(script, Options{NodeJS: true, BaseDir: baseDir, Console: io.Discard, Timeout: time.Second})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(runtime.Close)
|
|
return runtime
|
|
}
|
|
|
|
if err := newRuntime(`
|
|
function sendMessage() { process.exit(0); }
|
|
`).Call("sendMessage"); err != nil {
|
|
t.Fatalf("process.exit(0) should be a normal termination: %v", err)
|
|
}
|
|
if err := newRuntime(`
|
|
async function sendMessage() { process.exit(0); }
|
|
`).Call("sendMessage"); err != nil {
|
|
t.Fatalf("async process.exit(0) should be a normal termination: %v", err)
|
|
}
|
|
|
|
failure, err := New(`
|
|
function sendMessage() { process.exit(3); }
|
|
`, Options{NodeJS: true, BaseDir: baseDir, Console: io.Discard, Timeout: time.Second})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer failure.Close()
|
|
if err := failure.Call("sendMessage"); err == nil || !strings.Contains(err.Error(), "exited with code 3") {
|
|
t.Fatalf("process.exit(3) should fail with the exit code, got: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestAsyncProcessExitZeroIsNotReportedAsFailure(t *testing.T) {
|
|
var output bytes.Buffer
|
|
runtime, err := New(`
|
|
function sendMessage() {
|
|
setTimeout(() => process.exit(0), 0);
|
|
return true;
|
|
}
|
|
`, Options{NodeJS: true, BaseDir: t.TempDir(), Console: &output, Timeout: time.Second})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer runtime.Close()
|
|
if err := runtime.Call("sendMessage"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
time.Sleep(80 * time.Millisecond)
|
|
if strings.Contains(output.String(), "callback failed") {
|
|
t.Fatalf("process.exit(0) in a timer was reported as a failure: %s", output.String())
|
|
}
|
|
}
|
|
|
|
func TestHTTPClientRequestErrorWithoutListenerStillCloses(t *testing.T) {
|
|
server := httptest.NewServer(http.HandlerFunc(func(http.ResponseWriter, *http.Request) {}))
|
|
url := server.URL
|
|
server.Close()
|
|
|
|
var output bytes.Buffer
|
|
runtime, err := New(`
|
|
function sendMessage(url) {
|
|
return new Promise((resolve) => {
|
|
const request = require("http").get(url);
|
|
request.on("close", () => resolve(true));
|
|
});
|
|
}
|
|
`, Options{NodeJS: true, BaseDir: t.TempDir(), Console: &output, Timeout: 3 * time.Second})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer runtime.Close()
|
|
if err := runtime.Call("sendMessage", url); err != nil {
|
|
t.Fatalf("request close did not fire after connection failure: %v", err)
|
|
}
|
|
time.Sleep(80 * time.Millisecond)
|
|
if !strings.Contains(output.String(), "setTimeout callback failed") {
|
|
t.Fatalf("unhandled request error was not surfaced: %s", output.String())
|
|
}
|
|
}
|
|
|
|
func TestNodeFSSymlinkOperationsDoNotFollowFinalLink(t *testing.T) {
|
|
baseDir := t.TempDir()
|
|
target := filepath.Join(baseDir, "target.txt")
|
|
link := filepath.Join(baseDir, "link.txt")
|
|
if err := os.WriteFile(target, []byte("keep"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.Symlink(target, link); err != nil {
|
|
t.Skipf("symlinks are unavailable: %v", err)
|
|
}
|
|
targetDir := filepath.Join(baseDir, "target-dir")
|
|
linkDir := filepath.Join(baseDir, "link-dir")
|
|
if err := os.Mkdir(targetDir, 0o700); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(targetDir, "keep.txt"), []byte("keep"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.Symlink(targetDir, linkDir); err != nil {
|
|
t.Skipf("directory symlinks are unavailable: %v", err)
|
|
}
|
|
|
|
runtime, err := New(`
|
|
async function verify() {
|
|
const fs = require("fs");
|
|
const stat = fs.lstatSync("link.txt");
|
|
const destination = fs.readlinkSync("link.txt");
|
|
await fs.promises.unlink("link.txt");
|
|
await fs.promises.rm("link-dir", { recursive: true });
|
|
return stat.isSymbolicLink() && destination.length > 0 && !fs.existsSync("link.txt") && !fs.existsSync("link-dir") &&
|
|
fs.readFileSync("target.txt", "utf8") === "keep" && fs.readFileSync("target-dir/keep.txt", "utf8") === "keep";
|
|
}
|
|
`, Options{NodeJS: true, BaseDir: baseDir, Console: io.Discard, Timeout: 3 * time.Second})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer runtime.Close()
|
|
if err := runtime.Call("verify"); err != nil {
|
|
t.Fatalf("symlink operation followed final link: %v", err)
|
|
}
|
|
if content, err := os.ReadFile(target); err != nil || string(content) != "keep" {
|
|
t.Fatalf("symlink target changed: content=%q err=%v", content, err)
|
|
}
|
|
if content, err := os.ReadFile(filepath.Join(targetDir, "keep.txt")); err != nil || string(content) != "keep" {
|
|
t.Fatalf("directory symlink target changed: content=%q err=%v", content, err)
|
|
}
|
|
}
|
|
|
|
func TestNodeFSClosedRootNeverFallsBackToHostPath(t *testing.T) {
|
|
root := t.TempDir()
|
|
baseDir := filepath.Join(root, "base")
|
|
outside := filepath.Join(root, "outside")
|
|
if err := os.MkdirAll(filepath.Join(baseDir, "parent"), 0o700); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.Mkdir(outside, 0o700); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
jsRuntime, err := New(`function verify() { return true; }`, Options{
|
|
NodeJS: true, BaseDir: baseDir, Console: io.Discard,
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer jsRuntime.Close()
|
|
|
|
resolved, err := jsRuntime.resolveNodePath(filepath.Join("parent", "escaped.txt"), true)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
jsRuntime.fsModule.Close()
|
|
if err := os.Rename(filepath.Join(baseDir, "parent"), filepath.Join(baseDir, "original-parent")); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.Symlink(outside, filepath.Join(baseDir, "parent")); err != nil {
|
|
t.Skipf("symlinks are unavailable: %v", err)
|
|
}
|
|
|
|
if err := jsRuntime.nodeWriteFile(resolved, []byte("escape"), 0o600); err == nil {
|
|
t.Fatal("closed filesystem accepted a path operation")
|
|
}
|
|
if _, err := os.Stat(filepath.Join(outside, "escaped.txt")); !os.IsNotExist(err) {
|
|
t.Fatalf("closed filesystem fell back outside BaseDir: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestNodeFSAccessModeIsValidated(t *testing.T) {
|
|
jsRuntime, err := New(`
|
|
async function verify() {
|
|
const fs = require("fs");
|
|
fs.writeFileSync("access.txt", "ok");
|
|
let syncInvalid = false;
|
|
try { fs.accessSync("access.txt", 8); }
|
|
catch (error) { syncInvalid = error.code === "EINVAL"; }
|
|
const asyncInvalid = await new Promise((resolve) => fs.access("access.txt", 8, (error) => resolve(error && error.code === "EINVAL")));
|
|
const exists = await new Promise((resolve) => fs.access("access.txt", fs.constants.F_OK, (error) => resolve(!error)));
|
|
return syncInvalid && asyncInvalid && exists;
|
|
}
|
|
`, Options{NodeJS: true, BaseDir: t.TempDir(), Console: io.Discard, Timeout: 3 * time.Second})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer jsRuntime.Close()
|
|
if err := jsRuntime.Call("verify"); err != nil {
|
|
t.Fatalf("fs.access mode validation failed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestNodeFSCallbackAndPromiseShapes(t *testing.T) {
|
|
runtime, err := New(`
|
|
async function verify() {
|
|
const fs = require("fs");
|
|
const handle = await fs.promises.open("shape.txt", "w+");
|
|
if (typeof handle.fd !== "number" || typeof handle.close !== "function") return false;
|
|
const written = await handle.write(Buffer.from("shape"), 0, 5, 0);
|
|
const target = Buffer.alloc(5);
|
|
const read = await handle.read(target, 0, 5, 0);
|
|
const callbackShape = await new Promise((resolve, reject) => {
|
|
const second = Buffer.alloc(5);
|
|
fs.read(handle.fd, second, 0, 5, 0, (error, bytesRead, buffer) => {
|
|
if (error) reject(error); else resolve(bytesRead === 5 && buffer === second && buffer.toString() === "shape");
|
|
});
|
|
});
|
|
await handle.close();
|
|
return written.bytesWritten === 5 && written.buffer.toString() === "shape" &&
|
|
read.bytesRead === 5 && read.buffer === target && target.toString() === "shape" && callbackShape;
|
|
}
|
|
`, Options{NodeJS: true, BaseDir: t.TempDir(), Console: io.Discard, Timeout: 3 * time.Second})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer runtime.Close()
|
|
if err := runtime.Call("verify"); err != nil {
|
|
t.Fatalf("fs callback or Promise shape failed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestNodeFSAsyncIOLeavesEventLoopResponsive(t *testing.T) {
|
|
reader, writer, err := os.Pipe()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer writer.Close()
|
|
|
|
runtime, err := New(`
|
|
function verify(fd) {
|
|
const fs = require("fs");
|
|
fs.read(fd, Buffer.alloc(1), 0, 1, null, () => {});
|
|
return new Promise((resolve) => setTimeout(() => resolve(true), 20));
|
|
}
|
|
`, Options{NodeJS: true, BaseDir: t.TempDir(), Console: io.Discard, Timeout: 500 * time.Millisecond})
|
|
if err != nil {
|
|
reader.Close()
|
|
t.Fatal(err)
|
|
}
|
|
defer runtime.Close()
|
|
|
|
resourceID := runtime.addNodeResource(func() { _ = reader.Close() })
|
|
if resourceID == 0 {
|
|
t.Fatal("failed to register pipe")
|
|
}
|
|
runtime.fileMu.Lock()
|
|
runtime.fileID++
|
|
fd := runtime.fileID
|
|
runtime.files[fd] = nodeFileHandle{file: reader, resourceID: resourceID}
|
|
runtime.fileMu.Unlock()
|
|
|
|
if err := runtime.Call("verify", fd); err != nil {
|
|
t.Fatalf("fs.read blocked the event loop: %v", err)
|
|
}
|
|
_, _ = writer.Write([]byte{1})
|
|
}
|
|
|
|
func TestNodeResourceRegistrationAfterCloseClosesImmediately(t *testing.T) {
|
|
runtime, err := New(`function verify() { return true; }`, Options{NodeJS: true, BaseDir: t.TempDir(), Console: io.Discard})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
runtime.Close()
|
|
var closed atomic.Bool
|
|
if id := runtime.addNodeResource(func() { closed.Store(true) }); id != 0 {
|
|
t.Fatalf("closed Runtime accepted resource %d", id)
|
|
}
|
|
if !closed.Load() {
|
|
t.Fatal("late resource was not closed")
|
|
}
|
|
}
|
|
|
|
func TestNodeRootRejectsParentSymlinkSwap(t *testing.T) {
|
|
baseDir := t.TempDir()
|
|
parent := filepath.Join(baseDir, "parent")
|
|
outside := t.TempDir()
|
|
if err := os.Mkdir(parent, 0o700); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
jsRuntime, err := New(`function verify() { return true; }`, Options{NodeJS: true, BaseDir: baseDir, Console: io.Discard})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer jsRuntime.Close()
|
|
resolved, err := jsRuntime.resolveNodePath(filepath.Join("parent", "escaped.txt"), true)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.Rename(parent, filepath.Join(baseDir, "original-parent")); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.Symlink(outside, parent); err != nil {
|
|
t.Skipf("symlinks are unavailable: %v", err)
|
|
}
|
|
if err := jsRuntime.nodeWriteFile(resolved, []byte("escape"), 0o600); err == nil {
|
|
t.Fatal("rooted write followed a swapped parent symlink")
|
|
}
|
|
if _, err := os.Stat(filepath.Join(outside, "escaped.txt")); !os.IsNotExist(err) {
|
|
t.Fatalf("write escaped BaseDir: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestNodeFSErrorsExposeNodeFields(t *testing.T) {
|
|
jsRuntime, err := New(`
|
|
async function verify() {
|
|
try {
|
|
await require("fs").promises.readFile("missing.txt");
|
|
return false;
|
|
} catch (error) {
|
|
return error.name === "Error" && error.code === "ENOENT" &&
|
|
typeof error.errno === "number" && error.errno < 0 && typeof error.syscall === "string" &&
|
|
typeof error.path === "string";
|
|
}
|
|
}
|
|
`, Options{NodeJS: true, BaseDir: t.TempDir(), Console: io.Discard})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer jsRuntime.Close()
|
|
if err := jsRuntime.Call("verify"); err != nil {
|
|
t.Fatalf("fs error shape is not Node-compatible: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestNodePathCrossPlatformSemantics(t *testing.T) {
|
|
runtime, err := New(`
|
|
function verify() {
|
|
const path = require("path");
|
|
return path.extname("a.") === "." && path.extname("a..") === "." && path.extname(".hidden") === "" &&
|
|
path.posix.basename("/") === "" && path.posix.parse("/").base === "" && path.posix.parse("foo").dir === "" &&
|
|
path.posix.normalize("a\\b") === "a\\b" && path.posix.normalize("foo/bar//") === "foo/bar/" &&
|
|
path.posix.join("foo", "bar/") === "foo/bar/" &&
|
|
path.posix.relative("/", "/a") === "a" && path.posix.relative("/a", "/") === ".." &&
|
|
path.posix.resolve("a").endsWith("/a") &&
|
|
path.win32.normalize("C:/foo/../bar/a.") === "C:\\bar\\a." &&
|
|
path.win32.basename("C:foo") === "foo" && path.win32.parse("C:foo").base === "foo" &&
|
|
path.win32.parse("\\\\server\\share\\").root === "\\\\server\\share\\" &&
|
|
path.win32.resolve("C:\\base", "C:foo") === "C:\\base\\foo" &&
|
|
path.win32.resolve("C:\\base", "\\foo") === "C:\\foo" &&
|
|
path.win32.join("C:\\a", "b") === "C:\\a\\b" && path.win32.isAbsolute("C:\\a") &&
|
|
path.win32.resolve("C:\\a") === "C:\\a" &&
|
|
path.win32.relative("C:\\a\\b", "C:\\a\\c") === "..\\c" &&
|
|
path.win32.format({ dir: "C:\\a", name: "b", ext: "txt" }) === "C:\\a\\b.txt" &&
|
|
path.win32.toNamespacedPath("C:\\a") === "\\\\?\\C:\\a";
|
|
}
|
|
`, Options{NodeJS: true, BaseDir: t.TempDir(), Console: io.Discard})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer runtime.Close()
|
|
if err := runtime.Call("verify"); err != nil {
|
|
t.Fatalf("path compatibility failed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestProcessNextTickPrecedesPromiseMicrotasks(t *testing.T) {
|
|
jsRuntime, err := New(`
|
|
function verify() {
|
|
const order = [];
|
|
Promise.resolve().then(() => {
|
|
order.push("promise-1");
|
|
process.nextTick(() => order.push("tick-2"));
|
|
});
|
|
Promise.resolve().then(() => order.push("promise-2"));
|
|
process.nextTick(() => order.push("tick-1"));
|
|
return new Promise((resolve) => setImmediate(() => resolve(order.join(",") === "tick-1,promise-1,promise-2,tick-2")));
|
|
}
|
|
`, Options{NodeJS: true, BaseDir: t.TempDir(), Console: io.Discard})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer jsRuntime.Close()
|
|
if err := jsRuntime.Call("verify"); err != nil {
|
|
t.Fatalf("process.nextTick ordering failed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestProcessNextTickPrecedesPromisesInAsyncHostCallback(t *testing.T) {
|
|
jsRuntime, err := New(`
|
|
function verify() {
|
|
return new Promise((resolve) => {
|
|
require("fs").exists("missing.txt", () => {
|
|
const order = [];
|
|
Promise.resolve().then(() => order.push("promise"));
|
|
process.nextTick(() => order.push("tick"));
|
|
setImmediate(() => resolve(order.join(",") === "tick,promise"));
|
|
});
|
|
});
|
|
}
|
|
`, Options{NodeJS: true, BaseDir: t.TempDir(), Console: io.Discard})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer jsRuntime.Close()
|
|
if err := jsRuntime.Call("verify"); err != nil {
|
|
t.Fatalf("process.nextTick ordering in an async host callback failed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestFetchResponseBodyLimit(t *testing.T) {
|
|
server := httptest.NewServer(http.HandlerFunc(func(response http.ResponseWriter, _ *http.Request) {
|
|
_, _ = response.Write([]byte("response-too-large"))
|
|
}))
|
|
defer server.Close()
|
|
|
|
jsRuntime, err := New(`
|
|
async function verify(url) {
|
|
try {
|
|
await fetch(url);
|
|
return false;
|
|
} catch (error) {
|
|
return error.name === "TypeError" && String(error).includes("HTTP body exceeds 8 bytes");
|
|
}
|
|
}
|
|
`, Options{Console: io.Discard, Timeout: time.Second, MaxHTTPBodyBytes: 8})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer jsRuntime.Close()
|
|
if err := jsRuntime.Call("verify", server.URL); err != nil {
|
|
t.Fatalf("fetch response limit failed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestNodeOSAndProcessMetrics(t *testing.T) {
|
|
runtime, err := New(`
|
|
function verify() {
|
|
const os = require("os");
|
|
const memory = process.memoryUsage();
|
|
const cpu = process.cpuUsage();
|
|
const resources = process.resourceUsage();
|
|
return os.totalmem() > 0 && os.freemem() > 0 && os.uptime() > 0 && os.cpus().length > 0 &&
|
|
typeof os.release() === "string" && os.release().length > 0 &&
|
|
typeof process.memoryUsage.rss === "function" && process.memoryUsage.rss() > 0 && memory.rss > 0 &&
|
|
cpu.user >= 0 && cpu.system >= 0 && resources.userCPUTime >= 0 && resources.systemCPUTime >= 0 && resources.maxRSS > 0;
|
|
}
|
|
`, Options{NodeJS: true, BaseDir: t.TempDir(), Console: io.Discard})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer runtime.Close()
|
|
if err := runtime.Call("verify"); err != nil {
|
|
t.Fatalf("os/process metrics failed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestChildProcessPermissionAndExecution(t *testing.T) {
|
|
denied, err := New(`
|
|
function verify() {
|
|
try { require("child_process"); return false; }
|
|
catch (error) { return String(error).includes("AllowExec"); }
|
|
}
|
|
`, Options{NodeJS: true, BaseDir: t.TempDir(), Console: io.Discard, Timeout: time.Second})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := denied.Call("verify"); err != nil {
|
|
denied.Close()
|
|
t.Fatalf("child_process permission failed: %v", err)
|
|
}
|
|
denied.Close()
|
|
|
|
command := "printf child"
|
|
if runtime.GOOS == "windows" {
|
|
command = "echo child"
|
|
}
|
|
allowed, err := New(`
|
|
function verify(command) {
|
|
const childProcess = require("child_process");
|
|
const syncOutput = childProcess.execSync(command, { encoding: "utf8" }).trim();
|
|
return new Promise((resolve) => {
|
|
const child = childProcess.spawn(command, [], { shell: true, encoding: "utf8" });
|
|
let output = "";
|
|
child.stdout.on("data", (chunk) => output += String(chunk));
|
|
child.on("close", (code) => resolve(code === 0 && syncOutput === "child" && output.trim() === "child"));
|
|
child.on("error", () => resolve(false));
|
|
});
|
|
}
|
|
`, Options{NodeJS: true, AllowExec: true, BaseDir: t.TempDir(), Console: io.Discard, Timeout: 5 * time.Second})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer allowed.Close()
|
|
if err := allowed.Call("verify", command); err != nil {
|
|
t.Fatalf("child_process execution failed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestChildProcessOutputLimitAndExitCode(t *testing.T) {
|
|
jsRuntime, err := New(`
|
|
function execFile(command, environment, maxBuffer) {
|
|
return new Promise((resolve) => {
|
|
require("child_process").execFile(
|
|
command,
|
|
["-test.run=^TestNodeChildProcessHelper$"],
|
|
{ env: environment, encoding: "utf8", maxBuffer },
|
|
(error, stdout) => resolve({ error, stdout })
|
|
);
|
|
});
|
|
}
|
|
async function verify(command, outputEnvironment, exitEnvironment) {
|
|
const limited = await execFile(command, outputEnvironment, 4096);
|
|
const commandLimited = await execFile(command, outputEnvironment, 64);
|
|
const exited = await execFile(command, exitEnvironment, 4096);
|
|
const valid = limited.error && limited.error.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER" &&
|
|
String(limited.error).includes("stdout maxBuffer length exceeded") && limited.stdout.length === 128 &&
|
|
commandLimited.error && commandLimited.error.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER" && commandLimited.stdout.length === 64 &&
|
|
exited.error && exited.error.code === 7;
|
|
if (!valid) {
|
|
throw new Error(JSON.stringify({
|
|
limitedError: String(limited.error), limitedCode: limited.error && limited.error.code,
|
|
limitedLength: limited.stdout && limited.stdout.length,
|
|
commandLimitedError: String(commandLimited.error), commandLimitedLength: commandLimited.stdout && commandLimited.stdout.length,
|
|
exitedError: String(exited.error), exitedCode: exited.error && exited.error.code
|
|
}));
|
|
}
|
|
return true;
|
|
}
|
|
`, Options{
|
|
NodeJS: true, AllowExec: true, BaseDir: t.TempDir(), Console: io.Discard,
|
|
Timeout: 3 * time.Second, MaxChildOutputBytes: 128,
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer jsRuntime.Close()
|
|
if jsRuntime.maxChildOutputBytes != 128 {
|
|
t.Fatalf("MaxChildOutputBytes = %d, want 128", jsRuntime.maxChildOutputBytes)
|
|
}
|
|
if err := jsRuntime.Call(
|
|
"verify",
|
|
os.Args[0],
|
|
childHelperEnvironment("output"),
|
|
childHelperEnvironment("exit"),
|
|
); err != nil {
|
|
t.Fatalf("child_process output limit or exit code failed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestChildProcessSyncTimeoutLeavesRuntimeUsable(t *testing.T) {
|
|
jsRuntime, err := New(`
|
|
function verify(command, environment) {
|
|
try {
|
|
require("child_process").execFileSync(
|
|
command,
|
|
["-test.run=^TestNodeChildProcessHelper$"],
|
|
{ env: environment, timeout: 40 }
|
|
);
|
|
return false;
|
|
} catch (_) {
|
|
return true;
|
|
}
|
|
}
|
|
function healthy() { return eval("6 * 7") === 42; }
|
|
`, Options{NodeJS: true, AllowExec: true, BaseDir: t.TempDir(), Console: io.Discard, Timeout: time.Second})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer jsRuntime.Close()
|
|
if err := jsRuntime.Call("verify", os.Args[0], childHelperEnvironment("sleep")); err != nil {
|
|
t.Fatalf("child_process sync timeout failed: %v", err)
|
|
}
|
|
if err := jsRuntime.Call("healthy"); err != nil {
|
|
t.Fatalf("runtime was unusable after child_process sync timeout: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestRuntimeCloseClearsNodeFileDescriptors(t *testing.T) {
|
|
jsRuntime, err := New(`
|
|
function verify() {
|
|
require("fs").openSync("held.txt", "w");
|
|
return true;
|
|
}
|
|
`, Options{NodeJS: true, BaseDir: t.TempDir(), Console: io.Discard})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := jsRuntime.Call("verify"); err != nil {
|
|
jsRuntime.Close()
|
|
t.Fatal(err)
|
|
}
|
|
jsRuntime.fileMu.Lock()
|
|
openBeforeClose := len(jsRuntime.files)
|
|
jsRuntime.fileMu.Unlock()
|
|
if openBeforeClose != 1 {
|
|
jsRuntime.Close()
|
|
t.Fatalf("expected one open descriptor, got %d", openBeforeClose)
|
|
}
|
|
jsRuntime.Close()
|
|
jsRuntime.fileMu.Lock()
|
|
openAfterClose := len(jsRuntime.files)
|
|
jsRuntime.fileMu.Unlock()
|
|
if openAfterClose != 0 {
|
|
t.Fatalf("Runtime.Close left %d descriptors registered", openAfterClose)
|
|
}
|
|
}
|
|
|
|
func TestNodeNetAndHTTPServers(t *testing.T) {
|
|
runtime, err := New(`
|
|
function verifyNet() {
|
|
const net = require("net");
|
|
return new Promise((resolve) => {
|
|
const server = net.createServer((socket) => socket.on("data", (data) => socket.end(data)));
|
|
server.listen(0, "127.0.0.1", () => {
|
|
const client = net.connect(server.address().port, "127.0.0.1");
|
|
let output = "";
|
|
client.setEncoding("utf8");
|
|
client.on("connect", () => client.write("echo"));
|
|
client.on("data", (data) => output += data);
|
|
client.on("end", () => server.close(() => resolve(output === "echo")));
|
|
client.on("error", () => resolve(false));
|
|
});
|
|
});
|
|
}
|
|
function verifyHTTP() {
|
|
const http = require("http");
|
|
return new Promise((resolve) => {
|
|
const server = http.createServer((request, response) => {
|
|
response.statusCode = 201;
|
|
response.setHeader("X-Node", "yes");
|
|
response.end("ready");
|
|
});
|
|
server.listen(0, "127.0.0.1", async () => {
|
|
const response = await fetch("http://127.0.0.1:" + server.address().port + "/test");
|
|
const text = await response.text();
|
|
server.close(() => resolve(response.status === 201 && response.headers.get("x-node") === "yes" && text === "ready"));
|
|
});
|
|
});
|
|
}
|
|
`, Options{NodeJS: true, AllowListen: true, BaseDir: t.TempDir(), Console: io.Discard, Timeout: 8 * time.Second})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer runtime.Close()
|
|
if err := runtime.Call("verifyNet"); err != nil {
|
|
t.Fatalf("Node net server failed: %v", err)
|
|
}
|
|
if err := runtime.Call("verifyHTTP"); err != nil {
|
|
t.Fatalf("Node HTTP server failed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestNodeCloseCancelsPendingListen(t *testing.T) {
|
|
jsRuntime, err := New(`
|
|
function verify(moduleName) {
|
|
const api = require(moduleName);
|
|
return new Promise((resolve) => {
|
|
let listened = false;
|
|
const servers = [];
|
|
for (let index = 0; index < 32; index++) {
|
|
const server = api.createServer();
|
|
servers.push(server);
|
|
server.on("listening", () => { listened = true; });
|
|
server.listen(0, "127.0.0.1");
|
|
let duplicateRejected = false;
|
|
try { server.listen(0, "127.0.0.1"); }
|
|
catch (_) { duplicateRejected = true; }
|
|
if (!duplicateRejected) return resolve(false);
|
|
server.close();
|
|
}
|
|
setTimeout(() => resolve(!listened && servers.every((server) => server.address() === null)), 100);
|
|
});
|
|
}
|
|
function verifyReuse(moduleName) {
|
|
const api = require(moduleName);
|
|
return new Promise((resolve) => {
|
|
const server = api.createServer();
|
|
let staleCallbackCalls = 0;
|
|
server.listen(0, "127.0.0.1", () => { staleCallbackCalls++; });
|
|
server.close();
|
|
setTimeout(() => {
|
|
server.listen(0, "127.0.0.1", () => {
|
|
server.close(() => resolve(staleCallbackCalls === 0));
|
|
});
|
|
}, 20);
|
|
});
|
|
}
|
|
`, Options{NodeJS: true, AllowListen: true, BaseDir: t.TempDir(), Console: io.Discard, Timeout: 3 * time.Second})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer jsRuntime.Close()
|
|
for _, moduleName := range []string{"net", "http"} {
|
|
if err := jsRuntime.Call("verify", moduleName); err != nil {
|
|
t.Fatalf("%s pending listen was not cancelled: %v", moduleName, err)
|
|
}
|
|
if err := jsRuntime.Call("verifyReuse", moduleName); err != nil {
|
|
t.Fatalf("%s server retained a cancelled listen callback: %v", moduleName, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestNodeListenPermission(t *testing.T) {
|
|
runtime, err := New(`
|
|
function verify() {
|
|
try { require("net").createServer().listen(0); return false; }
|
|
catch (error) { return String(error).includes("AllowListen"); }
|
|
}
|
|
`, Options{NodeJS: true, BaseDir: t.TempDir(), Console: io.Discard, Timeout: time.Second})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer runtime.Close()
|
|
if err := runtime.Call("verify"); err != nil {
|
|
t.Fatalf("listen permission failed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestEvalRemainsInterruptible(t *testing.T) {
|
|
runtime, err := New(`function verify() { eval("for (;;) {}"); return true; }`, Options{NodeJS: true, BaseDir: t.TempDir(), Console: io.Discard, Timeout: 40 * time.Millisecond})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer runtime.Close()
|
|
if err := runtime.Call("verify"); err == nil || !strings.Contains(err.Error(), "timeout") {
|
|
t.Fatalf("expected eval timeout, got %v", err)
|
|
}
|
|
}
|
|
|
|
const childHelperModeEnvironment = "KOMARI_JSRUNTIME_CHILD_HELPER_MODE"
|
|
|
|
func childHelperEnvironment(mode string) map[string]string {
|
|
environment := make(map[string]string)
|
|
for _, item := range os.Environ() {
|
|
name, value, found := strings.Cut(item, "=")
|
|
if found && name != "" {
|
|
environment[name] = value
|
|
}
|
|
}
|
|
environment[childHelperModeEnvironment] = mode
|
|
return environment
|
|
}
|
|
|
|
func TestNodeChildProcessHelper(t *testing.T) {
|
|
switch os.Getenv(childHelperModeEnvironment) {
|
|
case "":
|
|
return
|
|
case "output":
|
|
_, _ = io.WriteString(os.Stdout, strings.Repeat("x", 4096))
|
|
os.Exit(0)
|
|
case "exit":
|
|
os.Exit(7)
|
|
case "sleep":
|
|
time.Sleep(5 * time.Second)
|
|
os.Exit(0)
|
|
case "echo":
|
|
_, _ = io.Copy(os.Stdout, os.Stdin)
|
|
os.Exit(0)
|
|
default:
|
|
os.Exit(2)
|
|
}
|
|
}
|