Mock GRPC Clients in nestjs using jest

import { Injectable, Logger, OnModuleInit } from '@nestjs/common';
import { Client, ClientGrpc } from '@nestjs/microservices';
import { catchError, map } from 'rxjs';
import { ICmdUserUsecase } from 'src/adaptor/usecase/ICmdUserUsecase';
import { dataServiceGrpcOptions } from 'src/app/data.options';
import { ICmdRepo } from 'src/adaptor/repo/ICmdRepo';

@Injectable()
export class CmdUserUsecase implements ICmdUserUsecase, OnModuleInit {
  private dataCmdRepo: ICmdRepo;

  constructor(private readonly logger: Logger) {}

  @Client({
    ...dataServiceGrpcOptions,
  })
  dataServiceClientGrpc: ClientGrpc;

  onModuleInit() {
    this.dataCmdRepo = this.dataServiceClientGrpc.getService<ICmdRepo>('DataService');
  }

  async createUserProfile(data: any) {
    return new Promise((resolve, reject) => {
      const userData = this.dataCmdRepo.createUser(data).pipe(
        catchError((err) => {
          if (err.code === 2) {
            err.message = 'Data Server is down';
            throw new Error(err.message);
          } else {
            throw new Error(err.message);
          }
        }),
        map((results) => {
          return results;
        }),
      );
      userData.subscribe(
        (rate) => {
          resolve(rate);
        },
        (error) => {
          reject(error);
        },
      );
    });
  }

  async createUser(data: any): Promise<any> {
    return await this.createUserProfile(data)
      .then((res) => {
        this.logger.log(res);
        return res;
      })
      .catch((err) => {
        
        return err;
      });
  }
}

here is the client service code which is utilizing the grpc services, every time I am getting connection not found from my spec file, how can I mock this foresaid grpc service in spec files.

import { INestApplication, Logger } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';
import { ClientsModule } from '@nestjs/microservices';
import { Test, TestingModule } from '@nestjs/testing';
import { ICmdUserUsecase } from 'src/adaptor/usecase/ICmdUserUsecase';
import { IQueryUserUsecase } from 'src/adaptor/usecase/IQueryUserUsecase';
import { userServiceGrpcOptions } from 'src/app/data.options';
import { configuration } from 'src/utils/configuration';
import { Mock } from 'src/utils/Mocks/mock';
import { MetricsTelemetryModule } from 'telemetry-lib';
import { QueryUserUsecase } from '../query-user-usecase/query.user.usecase';
import { CmdUserUsecase } from './cmd.user.usecase';

describe('CMD user usecase ', () => {
  let app: INestApplication;
  let cmdUserUsecase: CmdUserUsecase;
  beforeEach(async () => {
    const moduleRef: TestingModule = await Test.createTestingModule({
      imports: [
        ConfigModule.forRoot({
          load: [configuration],
          isGlobal: true,
          cache: true,
        }),
        MetricsTelemetryModule.forRoot({
          apiMetrics: true,
        }),

        ClientsModule.register([
          {
            name: 'USER_SERVICE',
            ...userServiceGrpcOptions,
          },
        ]),
      ],
      providers: [
        CmdUserUsecase,
        {
          provide: ICmdUserUsecase,
          useClass: CmdUserUsecase,
        },
        {
          provide: IQueryUserUsecase,
          useClass: QueryUserUsecase,
        },
        {
          provide: Logger,
          useValue: {
            log: jest.fn((data) => data),
          },
        },
      ],
      exports: [],
    }).compile();

    app = moduleRef.createNestApplication();
    await app.init();
    cmdUserUsecase = moduleRef.get<CmdUserUsecase>(CmdUserUsecase);
  });

  afterAll(async () => {
    await app.close();
  });

  describe('root', () => {
    it('CmdUserUsecase should be defined', () => {
      expect(cmdUserUsecase).toBeDefined();
    });

    it('CmdUserUsecase"s createUser should be called when invoked', async () => {
      try {
        await cmdUserUsecase.createUser(Mock.userMock);
        expect(cmdUserUsecase.createUser).toHaveBeenCalled();
      } catch (error) {
        expect(error).toEqual(error);
      }
    });

    it('CmdUserUsecase"s createUser should RETURN suceess message', async () => {
      try {
        const result = await cmdUserUsecase.createUser(Mock.userMock);
        expect(result.status).toBe('success');
      } catch (error) {
        expect(error).toEqual(error);
      }
    });

    it('CmdUserUsecase"s createUserProfile should be called when invoked', async () => {
      try {
        await cmdUserUsecase.createUserProfile(Mock.userMock);
        expect(cmdUserUsecase.createUserProfile).toHaveBeenCalled();
      } catch (error) {
        expect(error).toEqual(error);
      }
    });

    it('CmdUserUsecase"s createUserProfile should RETURN suceess message', async () => {
      try {
        const result = await cmdUserUsecase.createUserProfile(Mock.userMock);
        expect(result).toBe('success');
      } catch (error) {
        expect(error).toEqual(error);
      }
    });
  });
});

How can I modify the above spec file for so that it can contain the mock of the grpc clients as mentioned in the above code.