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

describe("[[DefineProperty]] trap normal behavior", () => {
  test("forwarding when not defined in handler", () => {
    let p = new Proxy({}, { defineProperty: null });
    expect(Object.defineProperty(p, "foo", {})).toBe(p);
    p = new Proxy({}, { defineProperty: undefined });
    expect(Object.defineProperty(p, "foo", {})).toBe(p);
    p = new Proxy({}, {});
    expect(Object.defineProperty(p, "foo", {})).toBe(p);
  });

  test("correct arguments passed to trap", () => {
    let o = {};
    p = new Proxy(o, {
      defineProperty(target, name, descriptor) {
        expect(target).toBe(o);
        expect(name).toBe("foo");
        expect(descriptor.configurable).toBeTrue();
        expect(descriptor.enumerable).toBeUndefined();
        expect(descriptor.writable).toBeTrue();
        expect(descriptor.value).toBe(10);
        expect(descriptor.get).toBeUndefined();
        expect(descriptor.set).toBeUndefined();
        return true;
      },
    });

    Object.defineProperty(p, "foo", { configurable: true, writable: true, value: 10 });
  });

  test("optionally ignoring the define call", () => {
    let o = {};
    let p = new Proxy(o, {
      defineProperty(target, name, descriptor) {
        if (target[name] === undefined) Object.defineProperty(target, name, descriptor);
        return true;
      },
    });

    Object.defineProperty(p, "foo", {
      value: 10,
      enumerable: true,
      configurable: false,
      writable: true,
    });
    expect(p).toHaveEnumerableProperty("foo");
    expect(p).not.toHaveConfigurableProperty("foo");
    expect(p).toHaveWritableProperty("foo");
    expect(p).toHaveValueProperty("foo", 10);
    expect(p).not.toHaveGetterProperty("foo");
    expect(p).not.toHaveSetterProperty("foo");

    Object.defineProperty(p, "foo", {
      value: 20,
      enumerable: true,
      configurable: false,
      writable: true,
    });
    expect(p).toHaveEnumerableProperty("foo");
    expect(p).not.toHaveConfigurableProperty("foo");
    expect(p).toHaveWritableProperty("foo");
    expect(p).toHaveValueProperty("foo", 10);
    expect(p).not.toHaveGetterProperty("foo");
    expect(p).not.toHaveSetterProperty("foo");
  });
});

describe("[[DefineProperty]] invariants", () => {
  test("trap can't return false", () => {
    let p = new Proxy(
      {},
      {
        defineProperty() {
          return false;
        },
      }
    );

    expect(() => {
      Object.defineProperty(p, "foo", {});
    }).toThrowWithMessage(TypeError, "Object's [[DefineProperty]] method returned false");
  });

  test("trap cannot return true for a non-extensible target if the property does not exist", () => {
    let o = {};
    Object.preventExtensions(o);
    let p = new Proxy(o, {
      defineProperty() {
        return true;
      },
    });

    expect(() => {
      Object.defineProperty(p, "foo", {});
    }).toThrowWithMessage(
      TypeError,
      "Proxy handler's defineProperty trap violates invariant: a property cannot be reported as being defined if the property does not exist on the target and the target is non-extensible"
    );
  });

  test("trap cannot return true for a non-configurable property if it doesn't already exist on the target", () => {
    let o = {};
    Object.defineProperty(o, "foo", { value: 10, configurable: true });
    let p = new Proxy(o, {
      defineProperty() {
        return true;
      },
    });

    expect(() => {
      Object.defineProperty(p, "bar", { value: 6, configurable: false });
    }).toThrowWithMessage(
      TypeError,
      "Proxy handler's defineProperty trap violates invariant: a property cannot be defined as non-configurable if it does not already exist on the target object"
    );
  });

  test("trap cannot return true for a non-configurable property if it already exists as a configurable property", () => {
    let o = {};
    Object.defineProperty(o, "foo", { value: 10, configurable: true });
    let p = new Proxy(o, {
      defineProperty() {
        return true;
      },
    });

    expect(() => {
      Object.defineProperty(p, "foo", { value: 6, configurable: false });
    }).toThrowWithMessage(
      TypeError,
      "Proxy handler's defineProperty trap violates invariant: a property cannot be defined as non-configurable if it already exists on the target object as a configurable property"
    );
  });
});