26 | describe('grpc identity', () => {
  27 |   let service: INestMicroservice
> 28 |   let client: any
     |               ^
  29 |
  30 |   beforeAll(async () => {
  31 |     const servicePort = await getPort()

  75 |
  76 |   it(`check success`, async () => {
> 77 |     const privateKey = readFileSync(join(__dirname, 'src/.jwks.pem'), 'utf-8')
     |                        ^
  78 |
  79 |     const token = sign({ sub: 'test' }, privateKey, { algorithm: 'RS256' })
  80 |

  100 |       await client.test({ id: 'test' }, metadata).toPromise()
  101 |     } catch (error) {
> 102 |       expect((error as any).code).toBe(status.UNAUTHENTICATED)
      |                        ^
  103 |     }
  104 |   })
  105 | })

> 1 | export declare const serverReflectionPath: any
    |                                            ^
  2 |

  76 |     channelWrapper.consume('test-queue', (msg) => {
  77 |       ;(async (): Promise<void> => {
> 78 |         const producer: Producer<any> = app.get(BATCH_QUEUE_PRODUCER)
     |                                  ^
  79 |         const parsed: { queueName: string; value: any } = JSON.parse(msg.content.toString())
  80 |         try {
  81 |           await producer.produce(parsed.queueName, parsed.value)

  77 |       ;(async (): Promise<void> => {
  78 |         const producer: Producer<any> = app.get(BATCH_QUEUE_PRODUCER)
> 79 |         const parsed: { queueName: string; value: any } = JSON.parse(msg.content.toString())
     |                                                   ^
  80 |         try {
  81 |           await producer.produce(parsed.queueName, parsed.value)
  82 |           succesProduceCount += 1

  120 |     await waitForConsumeCount(1, consumeBatchs)
  121 |     expect(consumeBatchs.length).toBe(1)
> 122 |     const result = consumeBatchs.pop()!
      |                    ^
  123 |     expect(result[0]).toBe('batch-queue')
  124 |     expect(result[1]).toEqual(['test-0-0'])
  125 |   })

  138 |     await waitForConsumeCount(1, consumeBatchs)
  139 |     expect(consumeBatchs.length).toBe(1)
> 140 |     const result = consumeBatchs.pop()!
      |                    ^
  141 |     expect(result[0]).toBe('batch-queue')
  142 |     const expectMessages = []
  143 |     for (let i = 0; i < 9_000; i += 1) {

  160 |     await waitForConsumeCount(1, consumeBatchs)
  161 |     expect(consumeBatchs.length).toBe(1)
> 162 |     const result = consumeBatchs.pop()!
      |                    ^
  163 |     expect(result[0]).toBe('batch-queue')
  164 |     const expectMessages = []
  165 |     for (let i = 0; i < 10_000; i += 1) {

  170 |
  171 |   it('handle multiple queues', async () => {
> 172 |     const messages: Array<Promise<any>> = []
      |                                   ^
  173 |     const queues: Array<string> = ['queue-one', 'queue-two', 'queue-three']
  174 |     const expectedResults: Record<string, Array<string>> = {
  175 |       'queue-one': [],

  114 |       // @ts-expect-error undefined method
  115 |       resultOrDeferred.subscribe({
> 116 |         next: (value: any) => {
      |                       ^
  117 |           subscriber.next(value as T)
  118 |         },
  119 |         error: (error: any) => {

  117 |           subscriber.next(value as T)
  118 |         },
> 119 |         error: (error: any) => {
      |                        ^
  120 |           subscriber.error(error)
  121 |         },
  122 |         complete: () => {

  22 | describe('grpc error', () => {
  23 |   let service: INestMicroservice
> 24 |   let client: PromiseClient<typeof TestService>
     |               ^
  25 |
  26 |   beforeAll(async () => {
  27 |     const port = await getPort()

  41 |     await service.listen()
  42 |
> 43 |     client = createPromiseClient(
     |              ^
  44 |       TestService,
  45 |       createGrpcTransport({
  46 |         baseUrl: `http://localhost:${port}`,

  63 |       if (error instanceof ConnectError) {
  64 |         expect(
> 65 |           // @ts-expect-error
     |           ^
  66 |           error.details.map((detail: { value: Uint8Array }) =>
  67 |             // @ts-expect-error
  68 |             ValidationError.fromBinary(detail.value))

  65 |           // @ts-expect-error
  66 |           error.details.map((detail: { value: Uint8Array }) =>
> 67 |             // @ts-expect-error
     |             ^
  68 |             ValidationError.fromBinary(detail.value))
  69 |         ).toEqual(
  70 |           expect.arrayContaining([

  66 |           error.details.map((detail: { value: Uint8Array }) =>
  67 |             // @ts-expect-error
> 68 |             ValidationError.fromBinary(detail.value))
     |             ^
  69 |         ).toEqual(
  70 |           expect.arrayContaining([
  71 |             expect.objectContaining({

  66 |           error.details.map((detail: { value: Uint8Array }) =>
  67 |             // @ts-expect-error
> 68 |             ValidationError.fromBinary(detail.value))
     |             ^
  69 |         ).toEqual(
  70 |           expect.arrayContaining([
  71 |             expect.objectContaining({

  33 |
  34 |   beforeEach(() => {
> 35 |     // @ts-expect-error
     |     ^
  36 |     processorFnMock = jest.fn()
  37 |   })
  38 |

  38 |
  39 |   beforeEach(() => {
> 40 |     // @ts-expect-error
     |     ^
  41 |     checkManager = {
  42 |       getState: jest.fn().mockReturnValue(true) as CheckManager['getState'],
  43 |     }

  133 |       this.mutexes.set(queueName, new Mutex())
  134 |     }
> 135 |     return this.mutexes.get(queueName)!
      |            ^
  136 |   }
  137 | }
  138 |

  21 |   useClass?: Type<BatchQueueOptionsFactory>
  22 |   useFactory?: (...args: Array<any>) => BatchQueueModuleOptions | Promise<BatchQueueModuleOptions>
> 23 |   inject?: Array<any>
     |                  ^
  24 | }
  25 |

  54 |     if (!(options.useExisting || options.useFactory)) {
  55 |       providers.push({
> 56 |         provide: options.useClass!,
     |                  ^
  57 |         useClass: options.useClass!,
  58 |       })
  59 |     }

  55 |       providers.push({
  56 |         provide: options.useClass!,
> 57 |         useClass: options.useClass!,
     |                   ^
  58 |       })
  59 |     }
  60 |     return providers