feat: Test Utils - Generate exhaustive boolean combinations and MockProxy spread (#1811)

New test util features
- Generate exhaustive boolean combinations
- Fixed some type errors in `usePickerWithSelectedValues.test.ts` (also
updated it to use the new boolean test util)
- Added spread support to MockProxy to avoid empty objects when making
copies
- Fixed a console error that was happening due to `null` icons passed to
FontAwesomeIcon component in tests

resolves #1809

Author: bmingles

packages/console/src/command-history/CommandHistoryActions.test.tsx

@@ -1,9 +1,24 @@
 import React from 'react';
 import { render, screen } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
+import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
+import { TestUtils } from '@deephaven/utils';
 import CommandHistoryActions from './CommandHistoryActions';
 
-jest.useFakeTimers();
+const { asMock } = TestUtils;
+
+jest.mock('@fortawesome/react-fontawesome', () => ({
+  FontAwesomeIcon: jest.fn(),
+}));
+
+beforeEach(() => {
+  jest.useFakeTimers();
+  asMock(FontAwesomeIcon).mockReturnValue(<div>Mock FontAwesomeIcon</div>);
+});
+
+afterAll(() => {
+  jest.useRealTimers();
+});
 
 const toBeClicked = jest.fn();
 const makeHistoryActionsMock = () => [

packages/jsapi-components/src/usePickerWithSelectedValues.test.ts

@@ -41,8 +41,12 @@ const tableUtils = createMockProxy<TableUtils>();
 
 const mock = {
   columnName: 'mock.columnName',
-  isDebouncingFalse: { isDebouncing: false },
-  isDebouncingTrue: { isDebouncing: true },
+  isDebouncingFalse: { isDebouncing: false } as ReturnType<
+    typeof useDebouncedValue
+  >,
+  isDebouncingTrue: { isDebouncing: true } as ReturnType<
+    typeof useDebouncedValue
+  >,
   filter: [
     createMockProxy<FilterCondition>(),
     createMockProxy<FilterCondition>(),
@@ -459,16 +463,7 @@ describe('searchTextExists', () => {
   // eslint-disable-next-line no-promise-executor-return
   const unresolvedPromise = new Promise<boolean>(() => undefined);
 
-  it.each([
-    // isLoading, isDebouncing, exists
-    // (at least one of `isLoading` or `isDebouncing` is true in all cases)
-    [true, true, true],
-    [true, true, false],
-    [true, false, true],
-    [true, false, false],
-    [false, true, true],
-    [false, true, false],
-  ])(
+  it.each(TestUtils.generateBooleanCombinations(3))(
     'should be null if check is in progress: isLoading:%s, isDebouncing:%s, valueExists:%s',
     async (valueExistsIsLoading, isDebouncing, valueExists) => {
       asMock(tableUtils.doesColumnValueExist).mockReturnValue(
@@ -477,13 +472,17 @@ describe('searchTextExists', () => {
 
       asMock(useDebouncedValue).mockReturnValue({
         isDebouncing,
-      });
+      } as ReturnType<typeof useDebouncedValue>);
 
       const { result } = await renderOnceAndWait();
 
       expect(useDebouncedValue).toHaveBeenCalledWith('', SEARCH_DEBOUNCE_MS);
 
-      expect(result.current.searchTextExists).toBeNull();
+      if (valueExistsIsLoading || isDebouncing) {
+        expect(result.current.searchTextExists).toBeNull();
+      } else {
+        expect(result.current.searchTextExists).toEqual(valueExists);
+      }
     }
   );
 

packages/utils/src/MockProxy.test.ts

@@ -85,4 +85,58 @@ describe('createMockProxy', () => {
     });
     expect(mock.testMethod).toBeInstanceOf(jest.fn().constructor);
   });
+
+  it.each([undefined, 'some label'])('should be spreadable: %s', label => {
+    const overrides = {
+      name: 'mock.name',
+      age: 42,
+    };
+
+    const mock = createMockProxy<{
+      name: string;
+      age: number;
+      testMethod: () => void;
+    }>(overrides, { label });
+
+    expect({ ...mock }).toEqual({
+      [MockProxySymbol.labelSymbol]: label ?? 'Mock Proxy',
+      name: 'mock.name',
+      age: 42,
+    });
+  });
+
+  it.each([undefined, true, false])(
+    'should include accessed auto proxy props if includeAutoProxiesInOwnKeys is true: %s',
+    includeAutoProxiesInOwnKeys => {
+      const overrides = {
+        name: 'mock.name',
+        age: 42,
+      };
+
+      const mock = createMockProxy<{
+        name: string;
+        age: number;
+        testMethod: () => void;
+      }>(overrides, { includeAutoProxiesInOwnKeys });
+
+      const expectedBase = {
+        [MockProxySymbol.labelSymbol]: 'Mock Proxy',
+        name: 'mock.name',
+        age: 42,
+      };
+
+      expect({ ...mock }).toEqual(expectedBase);
+
+      mock.testMethod();
+
+      if (includeAutoProxiesInOwnKeys === true) {
+        expect({ ...mock }).toEqual({
+          ...expectedBase,
+          testMethod: expect.any(Function),
+        });
+      } else {
+        expect({ ...mock }).toEqual(expectedBase);
+      }
+    }
+  );
 });

packages/utils/src/MockProxy.ts

@@ -1,8 +1,10 @@
+const labelSymbol: unique symbol = Symbol('mockProxyType');
 const defaultPropsSymbol: unique symbol = Symbol('mockProxyDefaultProps');
 const overridesSymbol: unique symbol = Symbol('mockProxyOverrides');
 const proxiesSymbol: unique symbol = Symbol('mockProxyProxies');
 
 export const MockProxySymbol = {
+  labelSymbol,
   defaultProps: defaultPropsSymbol,
   overrides: overridesSymbol,
   proxies: proxiesSymbol,
@@ -29,32 +31,53 @@ const mockProxyDefaultProps = {
  * The proxy target contains state + configuration for the proxy
  */
 export interface MockProxyTarget<T> {
+  [MockProxySymbol.labelSymbol]: string;
   [MockProxySymbol.defaultProps]: typeof mockProxyDefaultProps;
   [MockProxySymbol.overrides]: Partial<T>;
   [MockProxySymbol.proxies]: Record<keyof T, jest.Mock>;
 }
 
+export interface MockProxyConfig {
+  // Optional label to be assigned to the proxy object's
+  // `MockProxySymbol.labelSymbol` property.
+  label?: string;
+
+  // `ownKeys` has no way to know all of the potential auto proxy keys, but it
+  // can know auto proxies that have been called / cached. If this flag is true,
+  // include those in the `ownKeys` result. This is mostly useful for spread
+  // operations. Alternatively, the `overrides` are can explicitly include any
+  // proxies to be included in the `ownKeys` result without setting this flag.
+  // e.g. createMockProxy({ someMethod: jest.fn() }) would include `someMethod`.
+  includeAutoProxiesInOwnKeys?: boolean;
+}
+
 /**
  * Creates a mock object for a type `T` using a Proxy object. Each prop can
  * optionally be set via the constructor. Any prop that is not set will be set
  * to a jest.fn() instance on first access with the exeption of "then" which
  * will not be automatically proxied.
  * @param overrides Optional props to explicitly set on the Proxy.
- * @returns
+ * @param config Optional configuration for the proxy.
+ * @returns A mock Proxy object for type `T`.
  */
 export default function createMockProxy<T>(
-  overrides: Partial<T> = {}
+  overrides: Partial<T> = {},
+  {
+    label = 'Mock Proxy',
+    includeAutoProxiesInOwnKeys = false,
+  }: MockProxyConfig = {}
 ): T & MockProxyTarget<T> {
   const targetDef: MockProxyTarget<T> = {
+    [MockProxySymbol.labelSymbol]: label,
     [MockProxySymbol.defaultProps]: mockProxyDefaultProps,
     [MockProxySymbol.overrides]: overrides,
     [MockProxySymbol.proxies]: {} as Record<keyof T, jest.Mock>,
   };
 
   return new Proxy(targetDef, {
     get(target, name) {
-      if (name === Symbol.toStringTag) {
-        return 'Mock Proxy';
+      if (name === Symbol.toStringTag || name === MockProxySymbol.labelSymbol) {
+        return targetDef[MockProxySymbol.labelSymbol];
       }
 
       // Reserved attributes for the proxy
@@ -92,5 +115,25 @@ export default function createMockProxy<T>(
     has(target, name) {
       return name in target[MockProxySymbol.overrides];
     },
+    // Needed to support the spread (...) operator
+    getOwnPropertyDescriptor(_target, _prop) {
+      return { configurable: true, enumerable: true };
+    },
+    // Needed to support the spread (...) operator
+    ownKeys(target) {
+      const autoProxyKeys = includeAutoProxiesInOwnKeys
+        ? Reflect.ownKeys(target[MockProxySymbol.proxies])
+        : [];
+
+      const overridesKeys = Reflect.ownKeys(target[MockProxySymbol.overrides]);
+
+      return [
+        ...new Set<string | symbol>([
+          MockProxySymbol.labelSymbol,
+          ...autoProxyKeys,
+          ...overridesKeys,
+        ]),
+      ];
+    },
   }) as T & typeof targetDef;
 }

packages/utils/src/TestUtils.test.tsx

@@ -78,6 +78,40 @@ describe('findLastCall', () => {
   });
 });
 
+describe('generateBooleanCombinations', () => {
+  it.each([
+    [1, [[false], [true]]],
+    [
+      2,
+      [
+        [false, false],
+        [false, true],
+        [true, false],
+        [true, true],
+      ],
+    ],
+    [
+      3,
+      [
+        [false, false, false],
+        [false, false, true],
+        [false, true, false],
+        [false, true, true],
+        [true, false, false],
+        [true, false, true],
+        [true, true, false],
+        [true, true, true],
+      ],
+    ],
+  ])(
+    'should generate all possible combinations of boolean values',
+    (n, expected) => {
+      const result = TestUtils.generateBooleanCombinations(n);
+      expect(result).toEqual(expected);
+    }
+  );
+});
+
 describe('makeMockContext', () => {
   it('should make a MockContext object', () => {
     const mockContext = TestUtils.makeMockContext();

packages/utils/src/TestUtils.ts

@@ -1,5 +1,6 @@
 import type userEvent from '@testing-library/user-event';
 import createMockProxy from './MockProxy';
+import { Tuple } from './TypeUtils';
 
 interface MockContext {
   arc: jest.Mock<void>;
@@ -102,6 +103,30 @@ class TestUtils {
   ): TArgs | undefined =>
     TestUtils.asMock(fn).mock.calls.reverse().find(predicate);
 
+  /**
+   * Generate all possible combinations of boolean values for a given number of
+   * variables
+   * @param n The number of boolean values to generate combinations for.
+   * @returns An array of tuples representing all possible combinations
+   * of boolean values for the given number of values.
+   */
+  static generateBooleanCombinations = <T extends number>(
+    n: T
+  ): Tuple<boolean, T>[] => {
+    const combinations = 2 ** n;
+    const result: Tuple<boolean, T>[] = [];
+
+    // eslint-disable-next-line no-plusplus
+    for (let i = 0; i < combinations; i++) {
+      // eslint-disable-next-line no-bitwise
+      const binary = (i >>> 0).toString(2).padStart(n, '0');
+      const bitArray = Array.from(binary).map(bit => bit === '1');
+      result.push(bitArray as Tuple<boolean, T>);
+    }
+
+    return result;
+  };
+
   static makeMockContext(): MockContext {
     return {
       arc: jest.fn(),

packages/utils/src/TypeUtils.ts

@@ -27,6 +27,35 @@ export type OnlyOneProp<T> = {
   [P in keyof T]: { [ONEPROP in P]: T[ONEPROP] };
 }[keyof T];
 
+/**
+ * Tuple type.
+ * @param T Type of the items in the tuple
+ * @param N Length of the tuple
+ */
+export type Tuple<T, N extends number> = N extends 0
+  ? []
+  : N extends 1
+  ? [T]
+  : N extends 2
+  ? [T, T]
+  : N extends 3
+  ? [T, T, T]
+  : N extends 4
+  ? [T, T, T, T]
+  : N extends 5
+  ? [T, T, T, T, T]
+  : N extends 6
+  ? [T, T, T, T, T, T]
+  : N extends 7
+  ? [T, T, T, T, T, T, T]
+  : N extends 8
+  ? [T, T, T, T, T, T, T, T]
+  : N extends 9
+  ? [T, T, T, T, T, T, T, T, T]
+  : N extends 10
+  ? [T, T, T, T, T, T, T, T, T, T]
+  : Array<T>;
+
 /**
  * Remove `Partial` wrapper from a type. Note that this is slightly different
  * than `Required` because it will preserve optional properties on the original