@nestjs/testing doesn't work with vitest

It is actually the problem, believe it or not. Esbuild has partial decorator support, but it does not support emitDecoratorMetadata, which is how Nest automagically knows how to inject providers based on classes. With the @Exclude(), class-transformer is reading metadata specifically set for the property, not anything about the property type. For the @InjectModel(), once again, metadata is manually set for the parameter so Nest knows the injection token to use. If we were to create a new service Users2Service, like so:

import { Injectable } from "@nestjs/common";

@Injectable()
export class Users2Service {
  foo(): string {
    return "foo";
  }
}

And inject it into the UsersService and add a user2Foo to call the foo method

@Injectable()
export class UsersService {
  constructor(
    @InjectModel(User)
    private readonly userModel: typeof User,
    private readonly user2: Users2Service
  ) {}

  user2foo(): string {
    return this.user2.foo();
  }
...
}

and then create a users.service.vitest.spec.ts like so:

import { Test, TestingModule } from "@nestjs/testing";
import { User } from "./models/user.model";
import { UsersService } from "./users.service";
import { getModelToken } from "@nestjs/sequelize";
import { Users2Service } from "./user2.service";

import { beforeEach, describe, it, expect } from "vitest";
import * as vi from "vitest";

const usersArray = [
  {
    firstName: "firstName #1",
    lastName: "lastName #1",
  },
  {
    firstName: "firstName #3",
    lastName: "lastName #2",
  },
];

const oneUser = {
  firstName: "firstName #1",
  lastName: "lastName #1",
};

describe("UserService", () => {
  let service: UsersService;
  let model: typeof User;

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      providers: [
        UsersService,
        {
          provide: getModelToken(User),
          useValue: {
            findAll: vi.fn(() => usersArray),
            findOne: vi.fn(),
            create: vi.fn(() => oneUser),
            remove: vi.fn(),
            destroy: vi.fn(() => oneUser),
          },
        },
        {
          provide: Users2Service,
          useValue: {
            foo: () => "test foo",
          },
        },
      ],
    }).compile();

    service = module.get<UsersService>(UsersService);
    model = module.get<typeof User>(getModelToken(User));
  });

  it("should be defined", () => {
    expect(service).toBeDefined();
  });

  describe("user2foo", () => {
    it("should return test foo", () => {
      vi.expect(service.user2foo()).toBe("test foo");
    });
  });
});

And run it using npx vitest run src/users/users.service.vitest.spec.ts we’ll get the error that

 FAIL  src/users/users.service.vitest.spec.ts > UserService > user2foo > should return test foo
TypeError: Cannot read properties of undefined (reading 'foo')
 ❯ UsersService.user2foo src/users/users.service.ts:16:22
     14|
     15|   user2foo(): string {
     16|     return this.user2.foo();
       |                      ^
     17|   }
     18|
 ❯ src/users/users.service.vitest.spec.ts:104:24

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[1/1]⎯

Test Files  1 failed (1)
     Tests  1 failed | 1 passed (2)
      Time  1.64s (in thread 17ms, 9434.40%)

Meaning that Nest was not able to inject the Users2service because it doesn’t know what type to use.

You can use @Inject() on every one of your dependencies to set the token yourself, so that Nest isn’t trying to read the metadata emitted from the decorator, or you can use a tool that doesn’t use esbuild, because it will not support this feature.

Thanks much, now it’s crystal clear for me. Will see how can this be fixed from vite side