mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-16 20:11:08 +00:00
167 lines
6.0 KiB
JavaScript
167 lines
6.0 KiB
JavaScript
"use strict";
|
|
|
|
const assert = require("node:assert/strict");
|
|
const test = require("node:test");
|
|
|
|
const {
|
|
MAX_VISIBLE_FIELD_LENGTH,
|
|
MAX_VISIBLE_RESOURCES,
|
|
createNativePermissionDecisionProvider,
|
|
describePermissionRequest,
|
|
escapePermissionText,
|
|
} = require("./nativePermissionDecision.cjs");
|
|
|
|
function permissionRequest(overrides = {}) {
|
|
return {
|
|
requestId: "request-1",
|
|
pluginId: "com.example.permissions",
|
|
pluginName: "Permissions",
|
|
publisher: "example",
|
|
permission: "filesystem.read",
|
|
resources: ["/allowed"],
|
|
resourceKinds: ["directory"],
|
|
reason: "Read project files",
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
test("native permission decisions expose every host-owned grant scope", async () => {
|
|
for (const { sessionId, response, expected } of [
|
|
{ response: 0, expected: { requestId: "request-1", decision: "deny" } },
|
|
{ response: 1, expected: { requestId: "request-1", decision: "allow", scope: "once" } },
|
|
{ sessionId: "session-1", response: 2, expected: {
|
|
requestId: "request-1", decision: "allow", scope: "session",
|
|
} },
|
|
{ response: 2, expected: {
|
|
requestId: "request-1", decision: "allow", scope: "application",
|
|
} },
|
|
{ response: 3, expected: {
|
|
requestId: "request-1", decision: "allow", scope: "always",
|
|
} },
|
|
]) {
|
|
let captured;
|
|
const signal = new AbortController().signal;
|
|
const provider = createNativePermissionDecisionProvider({
|
|
dialog: {
|
|
async showMessageBox(_window, options) {
|
|
captured = options;
|
|
return { response };
|
|
},
|
|
},
|
|
window: {},
|
|
});
|
|
assert.deepEqual(await provider(permissionRequest({ sessionId }), { signal }), expected);
|
|
assert.equal(captured.signal, signal);
|
|
assert.equal(captured.cancelId, 0);
|
|
assert.match(captured.detail, /directory and descendants/u);
|
|
}
|
|
});
|
|
|
|
test("native permission decisions fail closed on cancellation and abort", async () => {
|
|
const provider = createNativePermissionDecisionProvider({
|
|
dialog: { showMessageBox: async () => ({ response: 999 }) },
|
|
});
|
|
assert.deepEqual(await provider(permissionRequest()), {
|
|
requestId: "request-1",
|
|
decision: "deny",
|
|
});
|
|
const controller = new AbortController();
|
|
controller.abort(new Error("runtime stopped"));
|
|
await assert.rejects(provider(permissionRequest(), { signal: controller.signal }), /runtime stopped/);
|
|
});
|
|
|
|
test("terminal interceptor permission prompts omit the unsupported one-use choice", async () => {
|
|
let captured;
|
|
const provider = createNativePermissionDecisionProvider({
|
|
dialog: {
|
|
async showMessageBox(options) {
|
|
captured = options;
|
|
return { response: 1 };
|
|
},
|
|
},
|
|
});
|
|
assert.deepEqual(await provider(permissionRequest({
|
|
sessionId: "session-1",
|
|
operationId: `terminal.interceptor.input:com.example.${"x".repeat(170)}`,
|
|
allowedScopes: ["session", "application", "always"],
|
|
})), {
|
|
requestId: "request-1",
|
|
decision: "allow",
|
|
scope: "session",
|
|
});
|
|
assert.deepEqual(captured.buttons, [
|
|
"Deny",
|
|
"Allow for Session",
|
|
"Allow for Application",
|
|
"Always Allow",
|
|
]);
|
|
});
|
|
|
|
test("native permission request details are bounded and preserve resource kinds", () => {
|
|
const resources = Array.from({ length: MAX_VISIBLE_RESOURCES + 5 }, (_, index) => `/path/${index}`);
|
|
const detail = describePermissionRequest(permissionRequest({
|
|
resources,
|
|
resourceKinds: resources.map(() => "exact"),
|
|
}));
|
|
assert.match(detail, /and 5 more/u);
|
|
assert.doesNotMatch(detail, /\/path\/24/u);
|
|
});
|
|
|
|
test("native permission dialogs visibly escape control and bidi characters", async () => {
|
|
let captured;
|
|
const provider = createNativePermissionDecisionProvider({
|
|
dialog: {
|
|
async showMessageBox(options) {
|
|
captured = options;
|
|
return { response: 0 };
|
|
},
|
|
},
|
|
});
|
|
await provider(permissionRequest({
|
|
pluginName: "Plugin\nPermission: vault.credentials",
|
|
publisher: "publisher\u202e",
|
|
reason: "Read this\r\nAlways Allow",
|
|
resources: ["/safe\nPermission: runtime.advanced"],
|
|
resourceKinds: ["exact"],
|
|
}));
|
|
assert.match(captured.message, /Plugin\\nPermission: vault\.credentials/u);
|
|
assert.match(captured.detail, /publisher\\u202e/u);
|
|
assert.match(captured.detail, /Read this\\r\\nAlways Allow/u);
|
|
assert.match(captured.detail, /\/safe\\nPermission: runtime\.advanced/u);
|
|
assert.equal(captured.detail.split("\n").filter((line) => line.startsWith("Permission:")).length, 1);
|
|
assert.equal(escapePermissionText("x".repeat(MAX_VISIBLE_FIELD_LENGTH + 20)).length, MAX_VISIBLE_FIELD_LENGTH);
|
|
});
|
|
|
|
test("native prompts share human-readable permission explanations and deny unknown permission IDs", async () => {
|
|
assert.match(describePermissionRequest(permissionRequest({ permission: "terminal.output" }), "zh-CN"), /读取终端输出/);
|
|
assert.match(describePermissionRequest(permissionRequest({ permission: "terminal.output" })), /credentials or private data/);
|
|
let prompts = 0;
|
|
const provider = createNativePermissionDecisionProvider({ dialog: { showMessageBox: async () => { prompts++; return { response: 1 }; } } });
|
|
assert.deepEqual(await provider(permissionRequest({ permission: "unknown.permission" })), { requestId: "request-1", decision: "deny" });
|
|
assert.equal(prompts, 0);
|
|
});
|
|
|
|
|
|
test("permission parent is resolved at prompt time without forcing focus", async () => {
|
|
const main = { name: "main" };
|
|
const settings = { name: "settings", isDestroyed: () => false };
|
|
let active = main;
|
|
const parents = [];
|
|
const provider = createNativePermissionDecisionProvider({
|
|
window: main,
|
|
getWindow: () => active,
|
|
dialog: { async showMessageBox(...args) {
|
|
parents.push(args.length === 2 ? args[0] : null);
|
|
return { response: 0 };
|
|
} },
|
|
});
|
|
await provider(permissionRequest());
|
|
active = settings;
|
|
await provider(permissionRequest());
|
|
active = { isDestroyed: () => true };
|
|
await provider(permissionRequest());
|
|
active = null;
|
|
await provider(permissionRequest());
|
|
assert.deepEqual(parents, [main, settings, null, main]);
|
|
});
|