add objectify tests

Author: lobsterkatie

packages/utils/test/object.test.ts

@@ -3,7 +3,14 @@
  */
 
 import * as isModule from '../src/is';
-import { dropUndefinedKeys, extractExceptionKeysForMessage, fill, normalize, urlEncode } from '../src/object';
+import {
+  dropUndefinedKeys,
+  extractExceptionKeysForMessage,
+  fill,
+  normalize,
+  objectify,
+  urlEncode,
+} from '../src/object';
 import { testOnlyIfNodeVersionAtLeast } from './testutils';
 
 describe('fill()', () => {
@@ -638,3 +645,67 @@ describe('dropUndefinedKeys()', () => {
     });
   });
 });
+
+describe('objectify()', () => {
+  it('turns undefined and null into `String` objects', () => {
+    const objectifiedUndefined = objectify(undefined);
+    const objectifiedNull = objectify(null);
+
+    // not string literals but instances of the class `String`
+    expect(objectifiedUndefined).toEqual(expect.any(String));
+    expect(objectifiedNull).toEqual(expect.any(String));
+
+    expect(objectifiedUndefined.valueOf()).toEqual('undefined');
+    expect(objectifiedNull.valueOf()).toEqual('null');
+  });
+
+  it('wraps other primitives with their respective object wrapper classes', () => {
+    // Note: BigInts are tested separately in order to be able to restrict the Node version on which the tests run
+    const numberPrimitive = 1121;
+    const stringPrimitive = 'Dogs are great!';
+    const booleanPrimitive = true;
+    const symbolPrimitive = Symbol('Maisey');
+
+    const objectifiedNumber = objectify(numberPrimitive);
+    const objectifiedString = objectify(stringPrimitive);
+    const objectifiedBoolean = objectify(booleanPrimitive);
+    const objectifiedSymbol = objectify(symbolPrimitive);
+
+    // not literals but instances of the respective wrapper classes
+    expect(objectifiedNumber).toEqual(expect.any(Number));
+    expect(objectifiedString).toEqual(expect.any(String));
+
+    // TODO: There's currently a bug in Jest - if you give it the `Boolean` class, it runs `typeof received ===
+    // 'boolean'` but not `received instanceof Boolean` (the way it correctly does for other primitive wrappers, like
+    // `Number` and `String). (See https://github.com/facebook/jest/pull/11976.) Once that is fixed and we upgrade jest,
+    // we can comment the test below back in. (The tests for symbols and bigints are working only because our current
+    // version of jest is sufficiently old that they're not even considered in the relevant check and just fall to the
+    // default `instanceof` check jest uses for all unknown classes.)
+
+    // expect(objectifiedBoolean).toEqual(expect.any(Boolean));
+    expect(objectifiedSymbol).toEqual(expect.any(Symbol));
+
+    expect(objectifiedNumber.valueOf()).toEqual(numberPrimitive);
+    expect(objectifiedString.valueOf()).toEqual(stringPrimitive);
+    expect(objectifiedBoolean.valueOf()).toEqual(booleanPrimitive);
+    expect(objectifiedSymbol.valueOf()).toEqual(symbolPrimitive);
+  });
+
+  // `BigInt` doesn't exist in Node < 10.
+  testOnlyIfNodeVersionAtLeast(10)('wraps bigints with the `BigInt` class', () => {
+    // @ts-ignore BigInts are new enough that our TS `target` value rules them out.
+    const bigintPrimitive = 'BigInt' in global ? 1231n : NaN;
+    const objectifiedBigInt = objectify(bigintPrimitive);
+
+    expect(objectifiedBigInt).toEqual(expect.any(BigInt));
+    expect(objectifiedBigInt.valueOf()).toEqual(bigintPrimitive);
+  });
+
+  it('leaves objects alone', () => {
+    const notAPrimitive = new Object();
+    const objectifiedNonPrimtive = objectify(notAPrimitive);
+
+    // `.toBe()` tests on identity, so this shows no wrapping has occurred
+    expect(objectifiedNonPrimtive).toBe(notAPrimitive);
+  });
+});