Mocking all class getters

[stychu]

I recently changes some of the class methods to be specifed as getters such as

public get someMethod()...

To my surprise this broke the whole suit of tests as earlier when the methods were accessed as someMethod() instead of now someMethods we were just mocking the whole module and all class methods were automatically mocked which we then could check calls tho the methods and values for the arguments. Now I have to specify spyOn on every single method we have in our classes in order to have a spy/mock for getters.

Is there a convenience method in Vitest to automatically spy on or mock all class getters, similar to how vi.mock can be used to mock a class's regular methods?

[hi-ogawa]

It looks like this has been discussed in the past and Vitest doesn't automock getter/setter.
(Though PR title says opposite, what's actually merged is the one to not automock getter/setter.)

• fix: automock getters and setters #1903 (comment)

---

Now I have to specify spyOn on every single method we have in our classes in order to have a spy/mock for getters.
Is there a convenience method in Vitest to automatically spy on or mock all class getters ...

Can you show how you are doing this? Still a boilerplate, but creating a helper on your own might be a way to ease the process.

import { test, vi } from "vitest";
import { SomeClass } from "./some-class";

// normal automocking + additional getters mocking
vi.mock("./some-class");
mockGetters(SomeClass.prototype);

// put this helper somewhere
function mockGetters(prototype) {
  const descs = Object.getOwnPropertyDescriptors(prototype);
  for (const [key, desc] of Object.entries(descs)) {
    if (desc.get) {
      vi.spyOn(prototype, key, "get").mockImplementation(() => {});
    }
  }
}

[stychu]

So now I just spyOn given getter.

import { locationSchemaMiddleware } from 'root-server/middlewares';
import { vi } from 'vitest';
import { getMockReq, getMockRes } from 'vitest-mock-express';

import { SCHEMA_COOKIE_KEY } from '$/lib/constants';
import { schemasMap } from '$/lib/entities/location-schema';
import { serverManagers } from '$/lib/server-managers';
import { locationApiClient } from '$/lib/services/location';

import type { LocationSchemas } from '$/lib/entities/location-schema';


vi.mock('$/lib/services/location');
vi.mock('$/lib/logger');
vi.mock('$/lib/server-managers');

 const getUserIdTokenSpy = vi.spyOn(
   serverManagers.user,
   'getUserIdToken',
   'get',
);

  it('should set currentSchemaId to default if not exist', async () => {
    const mockReq = getMockReq({});
    const { res, next } = getMockRes();

    mockApiCall(mockApi);

    await locationSchemaMiddleware(mockReq, res, next);

    expect(res.cookie).toHaveBeenCalledWith(
      SCHEMA_COOKIE_KEY,
      schemasMap.UK_ROI.id,
    );
    expect(getUserIdTokenSpy).toHaveBeenCalledOnce();
    expect(serverManagers.locationSchema.setProperties).toHaveBeenCalledOnce();
    expect(
      // @ts-ignore
      // eslint-disable-next-line @typescript-eslint/no-unsafe-call
      serverManagers.locationSchema.setProperties.mock.calls[0][0].getCurrentSchema(),
    ).toEqual(
      expect.objectContaining({
        id: schemasMap.UK_ROI.id,
      }),
    );
  });

Before I refactored the class method from function to getters it would be

expect(serverManagers.user.getUserIdToken).toHaveBeenCalledOnce();

I guess I can have a mockClassGetters helper this kinda works too.

...
const serverManagersUserMock = mockGetters(serverManagers.user);

type GetterTypes<T> = {
  [K in keyof T]: T[K] extends () => any ? ReturnType<T[K]> : never;
};

function mockGetters<T>(prototype: T): GetterTypes<T> {
  const mockedGetters: Partial<GetterTypes<T>> = {};
  const descs = Object.getOwnPropertyDescriptors(prototype);

  for (const key in descs) {
    const desc = descs[key];
    if (desc?.get) {
      const methodKey = key as keyof T;
      mockedGetters[methodKey] = vi.spyOn(
        prototype,
        methodKey as any,
        'get',
      ) as unknown as GetterTypes<T>[typeof methodKey];
    }
  }

  return mockedGetters as GetterTypes<T>;
}

#####

    expect(serverManagersUserMock.getUserIdToken).toHaveBeenCalledOnce();

[stychu]

still sad I have to do 'hacking' for class getters/setters. BUt I guess its a bit harder to do automock for those

[simon-abbott]

I've had this patch floating around ever since that PR got merged, since it broke our tests to have the getters just sitting there unmocked:

diff --git a/node_modules/vitest/dist/vendor-execute.07d1a420.js b/node_modules/vitest/dist/vendor-execute.07d1a420.js
index c6f103b..ceb3a31 100644
--- a/node_modules/vitest/dist/vendor-execute.07d1a420.js
+++ b/node_modules/vitest/dist/vendor-execute.07d1a420.js
@@ -217,7 +217,9 @@ ${c.green(`vi.mock("${mockpath}", async () => {
       for (const { key: property, descriptor } of getAllMockableProperties(container, isModule, this.primitives)) {
         if (!isModule && descriptor.get) {
           try {
-            Object.defineProperty(newContainer, property, descriptor);
+            const mockedDescriptor = {};
+            mockPropertiesOf(descriptor, mockedDescriptor);
+            Object.defineProperty(newContainer, property, mockedDescriptor);
           } catch (error) {
           }
           continue;

You can use patch-package to apply it, but it is annoying to keep around since the hash suffix on the file changes with every new version.

[simon-abbott]

Scratch that, as of 2.1.5 it seems to be fairly stable. Here's my new patch, called @vitest+mocker+2.1.5.patch (still applied via patch-package)

diff --git a/node_modules/@vitest/mocker/dist/index.js b/node_modules/@vitest/mocker/dist/index.js
index 4e8cc58..42a13c2 100644
--- a/node_modules/@vitest/mocker/dist/index.js
+++ b/node_modules/@vitest/mocker/dist/index.js
@@ -21,7 +21,10 @@ function mockObject(options, object, mockExports = {}) {
     )) {
       if (!isModule && descriptor.get) {
         try {
-          Object.defineProperty(newContainer, property, descriptor);
+          // This fixes getters/setters not being properly mocked.
+          const mockedDescriptor = {};
+          mockPropertiesOf(descriptor, mockedDescriptor);
+          Object.defineProperty(newContainer, property, mockedDescriptor);
         } catch {
         }
         continue;