ladybird/Libraries/LibJS/Tests/builtins/Proxy/Proxy.handler-getOwnPropertyDescriptor.js

describe("[Call][GetOwnProperty]] trap normal behavior", () => {
  test("forwarding when not defined in handler", () => {
    expect(
      Object.getOwnPropertyDescriptor(new Proxy({}, { getOwnPropertyDescriptor: null }), "a")
    ).toBeUndefined();
    expect(
      Object.getOwnPropertyDescriptor(new Proxy({}, { getOwnPropertyDescriptor: undefined }), "a")
    ).toBeUndefined();
    expect(Object.getOwnPropertyDescriptor(new Proxy({}, {}), "a")).toBeUndefined();
  });

  test("correct arguments supplied to trap", () => {
    let o = {};
    let p = new Proxy(o, {
      getOwnPropertyDescriptor(target, property) {
        expect(target).toBe(o);
        expect(property).toBe("foo");
      },
    });

    Object.getOwnPropertyDescriptor(p, "foo");
  });

  test("conditional returned descriptor", () => {
    let o = { foo: "bar" };
    Object.defineProperty(o, "baz", {
      value: "qux",
      enumerable: false,
      configurable: true,
      writable: false,
    });

    let p = new Proxy(o, {
      getOwnPropertyDescriptor(target, property) {
        if (property === "baz") return Object.getOwnPropertyDescriptor(target, "baz");
        return { value: target[property], enumerable: false, configurable: true, writable: true };
      },
    });

    expect(p).toHaveConfigurableProperty("baz");
    expect(p).not.toHaveEnumerableProperty("baz");
    expect(p).not.toHaveWritableProperty("baz");
    expect(p).toHaveValueProperty("baz", "qux");
    expect(p).not.toHaveGetterProperty("baz");
    expect(p).not.toHaveSetterProperty("baz");

    d = Object.getOwnPropertyDescriptor(p, "foo");

    expect(p).toHaveConfigurableProperty("foo");
    expect(p).not.toHaveEnumerableProperty("foo");
    expect(p).toHaveWritableProperty("foo");
    expect(p).toHaveValueProperty("foo", "bar");
    expect(p).not.toHaveGetterProperty("foo");
    expect(p).not.toHaveSetterProperty("foo");
  });
});

describe("[[GetOwnProperty]] invariants", () => {
  test("must return an object or undefined", () => {
    expect(() => {
      Object.getOwnPropertyDescriptor(
        new Proxy(
          {},
          {
            getOwnPropertyDescriptor() {
              return 1;
            },
          }
        )
      );
    }).toThrowWithMessage(
      TypeError,
      "Proxy handler's getOwnPropertyDescriptor trap violates invariant: must return an object or undefined"
    );
  });

  test("cannot return undefined for a non-configurable property", () => {
    let o = {};
    Object.defineProperty(o, "foo", { value: 10, configurable: false });

    let p = new Proxy(o, {
      getOwnPropertyDescriptor() {
        return undefined;
      },
    });

    expect(Object.getOwnPropertyDescriptor(p, "bar")).toBeUndefined();

    expect(() => {
      Object.getOwnPropertyDescriptor(p, "foo");
    }).toThrowWithMessage(
      TypeError,
      "Proxy handler's getOwnPropertyDescriptor trap violates invariant: cannot return undefined for a property on the target which is a non-configurable property"
    );
  });

  test("cannot return undefined for an existing property if the target is non-extensible", () => {
    let o = {};
    Object.defineProperty(o, "baz", {
      value: 20,
      configurable: true,
      writable: true,
      enumerable: true,
    });
    Object.preventExtensions(o);

    let p = new Proxy(o, {
      getOwnPropertyDescriptor() {
        return undefined;
      },
    });

    expect(() => {
      Object.getOwnPropertyDescriptor(p, "baz");
    }).toThrowWithMessage(
      TypeError,
      "Proxy handler's getOwnPropertyDescriptor trap violates invariant: cannot report a property as being undefined if it exists as an own property of the target and the target is non-extensible"
    );
  });

  test("invalid property descriptors", () => {
    let o = {};
    Object.defineProperty(o, "v1", { value: 10, configurable: false });
    Object.defineProperty(o, "v2", { value: 10, configurable: false, enumerable: true });
    Object.defineProperty(o, "v3", {
      configurable: false,
      get() {
        return 1;
      },
    });
    Object.defineProperty(o, "v4", {
      value: 10,
      configurable: false,
      writable: false,
      enumerable: true,
    });

    expect(() => {
      Object.getOwnPropertyDescriptor(
        new Proxy(o, {
          getOwnPropertyDescriptor() {
            return { configurable: true };
          },
        }),
        "v1"
      );
    }).toThrowWithMessage(
      TypeError,
      "Proxy handler's getOwnPropertyDescriptor trap violates invariant: invalid property descriptor for existing property on the target"
    );

    expect(() => {
      Object.getOwnPropertyDescriptor(
        new Proxy(o, {
          getOwnPropertyDescriptor() {
            return { enumerable: false };
          },
        }),
        "v2"
      );
    }).toThrowWithMessage(
      TypeError,
      "Proxy handler's getOwnPropertyDescriptor trap violates invariant: invalid property descriptor for existing property on the target"
    );

    expect(() => {
      Object.getOwnPropertyDescriptor(
        new Proxy(o, {
          getOwnPropertyDescriptor() {
            return { value: 10 };
          },
        }),
        "v3"
      );
    }).toThrowWithMessage(
      TypeError,
      "Proxy handler's getOwnPropertyDescriptor trap violates invariant: invalid property descriptor for existing property on the target"
    );

    expect(() => {
      Object.getOwnPropertyDescriptor(
        new Proxy(o, {
          getOwnPropertyDescriptor() {
            return { value: 10, writable: true };
          },
        }),
        "v4"
      );
    }).toThrowWithMessage(
      TypeError,
      "Proxy handler's getOwnPropertyDescriptor trap violates invariant: invalid property descriptor for existing property on the target"
    );
  });

  test("cannot report a property as non-configurable if it does not exist or is non-configurable", () => {
    let o = {};
    Object.defineProperty(o, "v", { configurable: true });
    expect(() => {
      Object.getOwnPropertyDescriptor(
        new Proxy(o, {
          getOwnPropertyDescriptor() {
            return { configurable: false };
          },
        }),
        "v"
      );
    }).toThrowWithMessage(
      TypeError,
      "Proxy handler's getOwnPropertyDescriptor trap violates invariant: cannot report target's property as non-configurable if the property does not exist, or if it is configurable"
    );
  });
});