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': [],

  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

  74 |       useFactory: async (optionsFactory: BatchQueueOptionsFactory) =>
  75 |         optionsFactory.createBatchQueueOptions(),
> 76 |       inject: [options.useExisting! || options.useClass!],
     |                ^
  77 |     }
  78 |   }
  79 | }

  74 |       useFactory: async (optionsFactory: BatchQueueOptionsFactory) =>
  75 |         optionsFactory.createBatchQueueOptions(),
> 76 |       inject: [options.useExisting! || options.useClass!],
     |                                        ^
  77 |     }
  78 |   }
  79 | }

  26 | ): Provider => ({
  27 |   provide: BATCH_QUEUE,
> 28 |   useFactory: (checkManager: CheckManager): BatchQueue<any> =>
     |                                                        ^
  29 |     new BatchQueue(batchQueueModuleOptions.core, checkManager),
  30 |   inject: [BATCH_QUEUE_CHECK_MANAGER],
  31 | })

  36 |     batchQueueModuleOptions: BatchQueueModuleOptions,
  37 |     checkManager: CheckManager
> 38 |   ): BatchQueue<any> => new BatchQueue(batchQueueModuleOptions.core, checkManager),
     |                 ^
  39 |   inject: [BATCH_QUEUE_MODULE_OPTIONS, BATCH_QUEUE_CHECK_MANAGER],
  40 | })
  41 |

  42 | export const createBatchQueueConsumerProvider = (): Provider => ({
  43 |   provide: BATCH_QUEUE_CONSUMER,
> 44 |   useFactory: (batchQueue: BatchQueue<any>): Consumer => new Consumer(batchQueue),
     |                                       ^
  45 |   inject: [BATCH_QUEUE],
  46 | })
  47 |

  48 | export const createBatchQueueProducerProvider = (): Provider => ({
  49 |   provide: BATCH_QUEUE_PRODUCER,
> 50 |   useFactory: (batchQueue: BatchQueue<any>): Producer<any> => new Producer(batchQueue),
     |                                       ^
  51 |   inject: [BATCH_QUEUE],
  52 | })
  53 |

  48 | export const createBatchQueueProducerProvider = (): Provider => ({
  49 |   provide: BATCH_QUEUE_PRODUCER,
> 50 |   useFactory: (batchQueue: BatchQueue<any>): Producer<any> => new Producer(batchQueue),
     |                                                       ^
  51 |   inject: [BATCH_QUEUE],
  52 | })
  53 |

  3 |
  4 | export class Consumer {
> 5 |   constructor(private batchQueue: BatchQueue<any>) {}
    |                                              ^
  6 |
  7 |   /**
  8 |    * Delegates to {@link BatchQueue.processBatch}