52a5a42147
If proxy has an undefined trap, it will fallback to target's internal_has_property, which will then check target's prototype for the requested property. If Proxy's prototype is set to the Proxy itself, it will check in itself in a loop, causing a stack overflow.
104 lines
3 KiB
JavaScript
104 lines
3 KiB
JavaScript
describe("[[Has]] trap normal behavior", () => {
|
|
test("forwarding when not defined in handler", () => {
|
|
expect("foo" in new Proxy({}, { has: null })).toBeFalse();
|
|
expect("foo" in new Proxy({}, { has: undefined })).toBeFalse();
|
|
expect("foo" in new Proxy({}, {})).toBeFalse();
|
|
});
|
|
|
|
test("correct arguments supplied to trap", () => {
|
|
let o = {};
|
|
let p = new Proxy(o, {
|
|
has(target, prop) {
|
|
expect(target).toBe(o);
|
|
expect(prop).toBe("foo");
|
|
return true;
|
|
},
|
|
});
|
|
|
|
"foo" in p;
|
|
});
|
|
|
|
test("correct arguments passed to trap even for number", () => {
|
|
let o = {};
|
|
let p = new Proxy(o, {
|
|
has(target, prop) {
|
|
expect(target).toBe(o);
|
|
expect(prop).toBe("1");
|
|
return true;
|
|
},
|
|
});
|
|
|
|
1 in p;
|
|
});
|
|
|
|
test("conditional return", () => {
|
|
let o = {};
|
|
let p = new Proxy(o, {
|
|
has(target, prop) {
|
|
if (target.checkedFoo) return true;
|
|
if (prop === "foo") target.checkedFoo = true;
|
|
return false;
|
|
},
|
|
});
|
|
|
|
expect("foo" in p).toBeFalse();
|
|
expect("foo" in p).toBeTrue();
|
|
});
|
|
});
|
|
|
|
describe("[[Has]] invariants", () => {
|
|
test("cannot return false if the property exists and is non-configurable", () => {
|
|
let o = {};
|
|
Object.defineProperty(o, "foo", { configurable: false });
|
|
|
|
p = new Proxy(o, {
|
|
has() {
|
|
return false;
|
|
},
|
|
});
|
|
|
|
expect(() => {
|
|
"foo" in p;
|
|
}).toThrowWithMessage(
|
|
TypeError,
|
|
"Proxy handler's has trap violates invariant: a property cannot be reported as non-existent if it exists on the target as a non-configurable property"
|
|
);
|
|
});
|
|
|
|
test("cannot return false if the property exists and the target is non-extensible", () => {
|
|
let o = {};
|
|
Object.defineProperty(o, "foo", { value: 10, configurable: true });
|
|
|
|
let p = new Proxy(o, {
|
|
has() {
|
|
return false;
|
|
},
|
|
});
|
|
|
|
Object.preventExtensions(o);
|
|
|
|
expect(() => {
|
|
"foo" in p;
|
|
}).toThrowWithMessage(
|
|
TypeError,
|
|
"Proxy handler's has trap violates invariant: a property cannot be reported as non-existent if it exists on the target and the target is non-extensible"
|
|
);
|
|
});
|
|
});
|
|
|
|
test("Proxy handler that has the Proxy itself as its prototype", () => {
|
|
const handler = {};
|
|
const proxy = new Proxy({}, handler);
|
|
handler.__proto__ = proxy;
|
|
expect(() => {
|
|
"foo" in proxy;
|
|
}).toThrowWithMessage(InternalError, "Call stack size limit exceeded");
|
|
});
|
|
|
|
test("Proxy that has the Proxy itself as its prototype", () => {
|
|
const proxy = new Proxy({}, {});
|
|
proxy.__proto__ = Object.create(proxy);
|
|
expect(() => {
|
|
"foo" in proxy;
|
|
}).toThrowWithMessage(InternalError, "Call stack size limit exceeded");
|
|
});
|