As promised, here are the tests
for the code I posted [here](/WzdgS2t0Mz6XFhAVme2V).

```typescript
import {
  BinderFn,
  ImmutabilityHelperFunctions,
  bindCustomFunction,
  parseChangeSetFactory,
  BindAccessorProps,
  BinderFnProps,
} from "./immutability-helper";

/** custom mockBindAccessor
 * necessary because bindAccessor returns
 * an anonymous function and we need it
 * to return a jest.fn() instead.
 */
const mockBindAccessor: (accessorProps: BindAccessorProps) => BinderFn =
  /** fetches an uncurried custom fn by some customFunctionId */

    ({ accessor }: BindAccessorProps) =>
    /** the BinderFn */
    (_innerProps: BinderFnProps) =>
      accessor(_innerProps.customFunctionId);

const mockFunctions: typeof ImmutabilityHelperFunctions = {
  "$identity-dedupe": jest.fn(),
};

const binder = mockBindAccessor({
  accessor: (key: keyof ImmutabilityHelperFunctions) =>
    mockFunctions[key]
});

const parseChangeSet = parseChangeSetFactory({
  binder,
});

describe("immutability-helper", () => {
  describe("parseChangeSetFactory", () => {
    it("does not affect untargeted specs", () => {
      expect(
        parseChangeSet(`
          $merge:
            email: testemail@domain.com

    `)
      ).toEqual({
        $merge: {
          email: "testemail@domain.com",
        },
      });
    });
    it(`
      maps a property that uses a custom 
      function id to a curried callback of 
      that actual function
    `, () => {
      expect(
        parseChangeSet(`
          memberIds:
            $identity-dedupe:
            - 1
            - 2
    `)
      ).toEqual({
        memberIds: {
          $apply: mockFunctions["$identity-dedupe"],
        },
      });
    });
    it(`
      handles multiple custom functions
    `, () => {
      expect(
        parseChangeSet(`
          memberIds:
            $identity-dedupe:
            - 1
            - 2
          otherField:
            arrayValues:
              $identity-dedupe:
              - 1
              - 2
    `)
      ).toEqual({
        memberIds: {
          $apply: mockFunctions["$identity-dedupe"],
        },
        otherField: {
          arrayValues: {
            $apply: mockFunctions["$identity-dedupe"],
          },
        },
      });
    });
    it(`
      handles $set
    `, () => {
      expect(
        parseChangeSet(`
          models:
            core--ghost-app-data:
              props:
                ghostAppId:
                  $set: invisible-ghost
      `)
      ).toEqual({
        models: {
          ["core--ghost-app-data"]: {
            props: {
              ghostAppId: {
                $set: "invisible-ghost",
              },
            },
          },
        },
      });
    });
  });
  describe("bindCustomFunction", () => {
    it("replaces memberIds value with transformed value", () => {
      expect(
        bindCustomFunction({
          binder,
          customFunctionId: "$identity-dedupe",
          args: [],
        })
      ).toEqual({
        $apply: mockFunctions["$identity-dedupe"],
      });
    });
  });
});

```