feat: add replayMock

Author: CreativeTechGuy

README.md

@@ -12,13 +12,15 @@
     -   [Use the mock to do literally anything](#use-the-mock-to-do-literally-anything)
     -   [Override the default proxy behavior with custom values](#override-the-default-proxy-behavior-with-custom-values)
     -   [Inspect what was done to the mock](#inspect-what-was-done-to-the-mock)
+    -   [Store and replay all operations](#store-and-replay-all-operations)
 -   [API Documentation](#api-documentation)
     -   [`recursiveProxyMock([overrides]) => Proxy`](#recursiveproxymockoverrides--proxy)
         -   [TypeScript Support](#typescript-support)
     -   [`ProxySymbol`](#proxysymbol)
     -   [`hasPathBeenVisited(proxy, path) => boolean`](#haspathbeenvisitedproxy-path--boolean)
     -   [`hasPathBeenCalledWith(proxy, path, args) => boolean`](#haspathbeencalledwithproxy-path-args--boolean)
     -   [`getVisitedPathData(proxy, path) => ProxyData[] | null`](#getvisitedpathdataproxy-path--proxydata--null)
+    -   [`replayMock(proxy, target)`](#replaymockproxy-target)
         -   [ProxyData](#proxydata)
     -   [`listAllProxyOperations(proxy) => ProxyData[]`](#listallproxyoperationsproxy--proxydata)
     -   [ProxyPath](#proxypath)
@@ -146,6 +148,21 @@ if (hasPathBeenCalledWith(mock, ["a", "b", "c", ProxySymbol.APPLY], ["hi", true,
 }
 ```
 
+### Store and replay all operations
+
+```ts
+import { recursiveProxyMock, replayProxy } from "recursive-proxy-mock";
+
+const mock = recursiveProxyMock();
+
+// Queue up operations on a mock
+mock.metrics.pageLoad(Date.now());
+mock.users.addUser("name");
+
+// Sometime later once the module is loaded
+replayProxy(mock, apiModule);
+```
+
 ## API Documentation
 
 ### `recursiveProxyMock([overrides]) => Proxy`
@@ -209,6 +226,15 @@ Function to get details about every time a path was visited. Useful in conjuncti
 
 -   `proxy` - the root proxy object that was returned from `recursiveProxyMock`
 -   `path` - see the [ProxyPath section](#proxypath) for more details.
+
+### `replayMock(proxy, target)`
+
+Replay every operation performed on a proxy mock object onto a target object. This can effectively let you time travel to queue up any actions and replay them as many times as you would like. Every property accessor, every function call, etc will be replayed onto the target.
+
+-   `proxy` - the root proxy object that was returned from `recursiveProxyMock`
+
+-   `target` - any object/function/class etc which will be operated on in the same way that the `proxy` object was.
+
 -   Returns: Array of `ProxyData` objects, one for each time the path was visited on the proxy object. `null` if it was never visited.
 
 #### ProxyData

lint-staged.config.js

@@ -1,6 +1,6 @@
 module.exports = {
     "*": "prettier --write --ignore-unknown",
-    "*.{js,ts,json,md}": "cspell",
+    "*.{js,ts,json,md}": "cspell --no-must-find-files",
     "*.{js,ts}": "eslint --max-warnings 0 --fix",
     "README.md": "npm run readme-toc",
 };

src/index.ts

@@ -5,6 +5,7 @@ export { hasPathBeenCalledWith } from "~/hasPathBeenCalledWith";
 export { getVisitedPathData } from "~/getVisitedPathData";
 export { listAllProxyOperations } from "~/listAllProxyOperations";
 export { isRecursiveProxyMock } from "~/isRecursiveProxyMock";
+export { replayProxy } from "~/replayProxy";
 export {
     ProxyData,
     ProxyOverrideConfig,

src/proxyTypes.ts

@@ -1,94 +1,94 @@
 // eslint-disable-next-line @typescript-eslint/no-unused-vars -- used in JSDoc
-import type { ProxySymbol } from "./ProxySymbol";
+import type { ProxySymbol } from "~/ProxySymbol";
 
-type ApplyProxyItem = {
+export type ApplyProxyItem = {
     name: "apply";
     pathKey: ProxyPath;
     args: unknown[];
     parent: number;
     self: number;
 };
 
-type ConstructProxyItem = {
+export type ConstructProxyItem = {
     name: "construct";
     pathKey: ProxyPath;
     args: unknown[];
     parent: number;
     self: number;
 };
 
-type DefinePropertyProxyItem = {
+export type DefinePropertyProxyItem = {
     name: "defineProperty";
     pathKey: ProxyPath;
     prop: string | symbol;
     descriptor: PropertyDescriptor;
     parent: number;
 };
 
-type DeletePropertyProxyItem = {
+export type DeletePropertyProxyItem = {
     name: "deleteProperty";
     pathKey: ProxyPath;
     prop: string | symbol;
     parent: number;
 };
 
-type GetProxyItem = {
+export type GetProxyItem = {
     name: "get";
     pathKey: ProxyPath;
     prop: string | symbol;
     parent: number;
     self: number;
 };
 
-type GetOwnPropertyDescriptorProxyItem = {
+export type GetOwnPropertyDescriptorProxyItem = {
     name: "getOwnPropertyDescriptor";
     pathKey: ProxyPath;
     prop: string | symbol;
     parent: number;
     self: number;
 };
 
-type GetPrototypeOfProxyItem = {
+export type GetPrototypeOfProxyItem = {
     name: "getPrototypeOf";
     pathKey: ProxyPath;
     parent: number;
     self: number;
 };
 
-type HasProxyItem = {
+export type HasProxyItem = {
     name: "has";
     pathKey: ProxyPath;
     prop: string | symbol;
     parent: number;
 };
 
-type IsExtensibleProxyItem = {
+export type IsExtensibleProxyItem = {
     name: "isExtensible";
     pathKey: ProxyPath;
     parent: number;
 };
 
-type OwnKeysProxyItem = {
+export type OwnKeysProxyItem = {
     name: "ownKeys";
     pathKey: ProxyPath;
     parent: number;
 };
 
-type PreventExtensionsProxyItem = {
+export type PreventExtensionsProxyItem = {
     name: "preventExtensions";
     pathKey: ProxyPath;
     parent: number;
 };
 
-type SetProxyItem = {
+export type SetProxyItem = {
     name: "set";
     pathKey: ProxyPath;
     prop: string | symbol;
     value: unknown;
     parent: number;
 };
 
-type SetPrototypeOfProxyItem = {
+export type SetPrototypeOfProxyItem = {
     name: "setPrototypeOf";
     pathKey: ProxyPath;
     // eslint-disable-next-line @typescript-eslint/ban-types

src/replayProxy/index.ts

@@ -0,0 +1 @@
+export { replayProxy } from "./replayProxy";

src/replayProxy/replayProxy.test.ts

@@ -0,0 +1,212 @@
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+import { replayProxy } from "./replayProxy";
+import { hasPathBeenVisited } from "~/hasPathBeenVisited";
+import { ProxySymbol } from "~/ProxySymbol";
+import { recursiveProxyMock } from "~/recursiveProxyMock";
+
+describe("replayProxy", () => {
+    test("console.warn when argument isn't a proxy mock", () => {
+        const consoleWarnSpy = jest.spyOn(console, "warn").mockImplementation();
+        replayProxy(null, []);
+        expect(consoleWarnSpy).toHaveBeenCalled();
+    });
+
+    test("example: store and replay operations", () => {
+        const greeter = jest.fn();
+        class TestClass {
+            public e(name: string): void {
+                greeter(`Hi ${name}`);
+            }
+        }
+        const target = {
+            a: {
+                b: function (): { c: TestClass } {
+                    return {
+                        c: new TestClass(),
+                    };
+                },
+            },
+        };
+        const proxy = recursiveProxyMock<typeof target>();
+        proxy.a.b().c.e("Jason");
+        replayProxy(proxy, target);
+        expect(greeter).toHaveBeenCalledWith("Hi Jason");
+    });
+
+    test("replay: apply", () => {
+        const target = jest.fn();
+        const proxy = recursiveProxyMock();
+        proxy("potato");
+        replayProxy(proxy, target);
+        expect(target).toHaveBeenCalledWith("potato");
+    });
+
+    test("replay: construct", () => {
+        const greeter = jest.fn();
+        class TestClass {
+            public e(name: string): void {
+                greeter(`Hi ${name}`);
+            }
+        }
+        const proxy = recursiveProxyMock<typeof TestClass>();
+        new proxy().e("test");
+        replayProxy(proxy, TestClass);
+        expect(greeter).toHaveBeenCalledWith("Hi test");
+    });
+
+    test("replay: defineProperty", () => {
+        const obj: Record<string, Record<string, number>> = {};
+        const proxy = recursiveProxyMock<typeof obj>();
+        Object.defineProperty(proxy, "k", {
+            value: {},
+            enumerable: true,
+            configurable: true,
+            writable: true,
+        });
+        Object.defineProperty(proxy.k, "number", {
+            value: 100,
+            enumerable: true,
+            configurable: true,
+            writable: true,
+        });
+        replayProxy(proxy, obj);
+        expect(obj).toStrictEqual({
+            k: {
+                number: 100,
+            },
+        });
+    });
+
+    test("replay: deleteProperty", () => {
+        type PartialObj = {
+            num?: number;
+            person: {
+                name?: string;
+            };
+        };
+        const obj: PartialObj = {
+            num: 7,
+            person: {
+                name: "Joe",
+            },
+        };
+        const proxy = recursiveProxyMock<PartialObj>();
+        delete proxy.num;
+        delete proxy.person.name;
+        replayProxy(proxy, obj);
+        expect(obj).toStrictEqual({
+            person: {},
+        });
+    });
+
+    test("replay: get", () => {
+        const getter = jest.fn();
+        const obj = {
+            a: {
+                b: {
+                    get c(): number {
+                        getter();
+                        return 7;
+                    },
+                },
+            },
+        };
+        const proxy = recursiveProxyMock<typeof obj>();
+        // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+        proxy.a.b.c;
+        replayProxy(proxy, obj);
+        expect(getter).toHaveBeenCalled();
+    });
+
+    test("replay: getOwnPropertyDescriptor", () => {
+        const obj = recursiveProxyMock<unknown>();
+        const proxy = recursiveProxyMock<typeof obj>();
+        Object.getOwnPropertyDescriptor(Object.getOwnPropertyDescriptor(proxy, "person")!.value, "name");
+        replayProxy(proxy, obj);
+        expect(
+            hasPathBeenVisited(obj, [
+                "person",
+                ProxySymbol.GET_OWN_PROPERTY_DESCRIPTOR,
+                "name",
+                ProxySymbol.GET_OWN_PROPERTY_DESCRIPTOR,
+            ])
+        ).toStrictEqual(true);
+    });
+
+    test("replay: getPrototypeOf", () => {
+        const obj = recursiveProxyMock<unknown>();
+        const proxy = recursiveProxyMock<typeof obj>();
+        Object.getPrototypeOf(proxy);
+        replayProxy(proxy, obj);
+        expect(hasPathBeenVisited(obj, [ProxySymbol.GET_PROTOTYPE_OF])).toStrictEqual(true);
+    });
+
+    test("replay: has", () => {
+        const obj = recursiveProxyMock<Record<string, unknown>>();
+        const proxy = recursiveProxyMock<typeof obj>();
+        // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+        "favorite" in proxy;
+        replayProxy(proxy, obj);
+        expect(hasPathBeenVisited(obj, ["favorite", ProxySymbol.HAS])).toStrictEqual(true);
+    });
+
+    test("replay: isExtensible", () => {
+        const obj = recursiveProxyMock<unknown>();
+        const proxy = recursiveProxyMock<typeof obj>();
+        Object.isExtensible(proxy);
+        replayProxy(proxy, obj);
+        expect(hasPathBeenVisited(obj, [ProxySymbol.IS_EXTENSIBLE])).toStrictEqual(true);
+    });
+
+    test("replay: isOwnKeys", () => {
+        const obj = recursiveProxyMock<Record<string, unknown>>();
+        const proxy = recursiveProxyMock<typeof obj>();
+        Object.keys(proxy);
+        replayProxy(proxy, obj);
+        expect(hasPathBeenVisited(obj, [ProxySymbol.OWN_KEYS])).toStrictEqual(true);
+    });
+
+    test("replay: preventExtensions", () => {
+        const obj = recursiveProxyMock<Record<string, unknown>>();
+        const proxy = recursiveProxyMock<typeof obj>();
+        expect(() => {
+            Object.preventExtensions(proxy);
+        }).toThrow(TypeError);
+        expect(() => {
+            replayProxy(proxy, obj);
+        }).toThrow(TypeError);
+        expect(hasPathBeenVisited(obj, [ProxySymbol.PREVENT_EXTENSIONS])).toStrictEqual(true);
+    });
+
+    test("replay: set", () => {
+        const obj = {
+            num: 7,
+            person: {
+                name: "Joe",
+            },
+        };
+        const proxy = recursiveProxyMock<typeof obj>();
+        proxy.num = 10;
+        proxy.person.name = "Bob";
+        replayProxy(proxy, obj);
+        expect(obj).toStrictEqual({
+            num: 10,
+            person: {
+                name: "Bob",
+            },
+        });
+    });
+
+    test("replay: setPrototypeOf", () => {
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        function target(): void {}
+        const proxy = recursiveProxyMock<typeof target>();
+        const prototype = {
+            getName: jest.fn(),
+        };
+        Object.setPrototypeOf(proxy, prototype);
+        replayProxy(proxy, target);
+        expect(Object.getPrototypeOf(target)).toStrictEqual(prototype);
+    });
+});