Added unit test

Author: jonathanedey

test/resources/mocks.ts

@@ -322,10 +322,11 @@ export interface MockHttp2Request {
 }
 
 export interface MockHttp2Response {
-  headers: http2.IncomingHttpHeaders & http2.IncomingHttpStatusHeader,
-  data: Buffer,
+  headers?: http2.IncomingHttpHeaders & http2.IncomingHttpStatusHeader,
+  data?: Buffer,
   delay?: number,
-  error?: any
+  sessionError?: any
+  streamError?: any,
 }
 
 export class Http2Mocker {
@@ -340,12 +341,12 @@ export class Http2Mocker {
     this.connectStub = sinon.stub(http2, 'connect');
     this.connectStub.callsFake((_target: any, options: any) => {
       const session = this.originalConnect('https://www.example.com', options);
-      session.request = this.createMockRequest()
+      session.request = this.createMockRequest(session)
       return session;
     })
   }
 
-  private createMockRequest() {
+  private createMockRequest(session:http2.ClientHttp2Session) {
     return (requestHeaders: http2.OutgoingHttpHeaders) => {
       // Create a mock ClientHttp2Stream to return
       const mockStream = new stream.Readable({
@@ -365,8 +366,11 @@ export class Http2Mocker {
       const mockRes = this.mockResponses.shift();
       if (mockRes) {
         this.timeouts.push(setTimeout(() => {
-          if (mockRes.error) {
-            mockStream.emit('error', mockRes.error)
+          if (mockRes.sessionError) {
+            session.emit('error', mockRes.sessionError)
+          }
+          if (mockRes.streamError) {
+            mockStream.emit('error', mockRes.streamError)
           }
           else {
             mockStream.emit('response', mockRes.headers);

test/unit/messaging/messaging.spec.ts

@@ -121,6 +121,12 @@ function mockHttp2SendRequestError(
   } as mocks.MockHttp2Response
 }
 
+function mockHttp2Error(streamError?: any, sessionError?:any): mocks.MockHttp2Response {
+  return {
+    streamError: streamError,
+    sessionError: sessionError
+  } as mocks.MockHttp2Response
+}
 
 function mockErrorResponse(
   path: string,
@@ -906,6 +912,29 @@ describe('Messaging', () => {
       });
     });
 
+    it('should throw error with BatchResponse promise on session error event using HTTP/2', () => {
+      mockedHttp2Responses.push(mockHttp2SendRequestResponse('projects/projec_id/messages/1'))
+      const sessionError = 'MOCK_SESSION_ERROR'
+      mockedHttp2Responses.push(mockHttp2Error(
+        new Error(`MOCK_STREAM_ERROR caused by ${sessionError}`),
+        new Error(sessionError)
+      ));
+      http2Mocker.http2Stub(mockedHttp2Responses)
+
+      return messaging.sendEach(
+        [validMessage, validMessage], true
+      ).catch(async (error) => {
+        expect(error.errorInfo.code).to.equal('app/http2-session-error')
+        await error.pendingBatchResponse.then((response: BatchResponse) => {
+          expect(http2Mocker.requests.length).to.equal(2);
+          expect(response.failureCount).to.equal(1);
+          const responses = response.responses;
+          checkSendResponseSuccess(responses[0], 'projects/projec_id/messages/1');
+          checkSendResponseFailure(responses[1], 'app/network-error');
+        })
+      });
+    })
+
     // This test was added to also verify https://github.com/firebase/firebase-admin-node/issues/1146
     it('should be fulfilled when called with different message types using HTTP/2', () => {
       const messageIds = [

test/unit/utils/api-request.spec.ts

@@ -140,12 +140,14 @@ function mockHttp2SendRequestError(
   } as mocks.MockHttp2Response
 }
 
-function mockHttp2Error(err: any): mocks.MockHttp2Response {
+function mockHttp2Error(streamError?: any, sessionError?:any): mocks.MockHttp2Response {
   return {
-    error: err
+    streamError: streamError,
+    sessionError: sessionError
   } as mocks.MockHttp2Response
 }
 
+
 /**
  * Returns a new RetryConfig instance for testing. This is same as the default
  * RetryConfig, with the backOffFactor set to 0 to avoid delays.
@@ -2500,6 +2502,43 @@ describe('Http2Client', () => {
       http2SessionHandler: http2SessionHandler
     }).should.eventually.be.rejectedWith(err).and.have.property('code', 'app/network-error');
   });
+
+  it('should fail on session and stream errors', async () => {
+    const reqData = { request: 'data' };
+    const streamError = 'Error while making request: test stream error. Error code: AWFUL_STREAM_ERROR';
+    const sessionError = 'Session error while making requests: Error: AWFUL_SESSION_ERROR'
+    mockedHttp2Responses.push(mockHttp2Error(
+      { message: 'test stream error', code: 'AWFUL_STREAM_ERROR' },
+      new Error('AWFUL_SESSION_ERROR')
+    ));
+    http2Mocker.http2Stub(mockedHttp2Responses);
+
+    const client = new Http2Client();
+    http2SessionHandler = new Http2SessionHandler(mockHostUrl)
+
+    await client.send({
+      method: 'POST',
+      url: mockUrl,
+      headers: {
+        'authorization': 'Bearer token',
+        'My-Custom-Header': 'CustomValue',
+      },
+      data: reqData,
+      http2SessionHandler: http2SessionHandler,
+    }).should.eventually.be.rejectedWith(streamError).and.have.property('code', 'app/network-error')
+      .then(() => {
+        expect(http2Mocker.requests.length).to.equal(1);
+        expect(http2Mocker.requests[0].headers[':method']).to.equal('POST');
+        expect(http2Mocker.requests[0].headers[':scheme']).to.equal('https:');
+        expect(http2Mocker.requests[0].headers[':path']).to.equal(mockPath);
+        expect(JSON.parse(http2Mocker.requests[0].data)).to.deep.equal(reqData);
+        expect(http2Mocker.requests[0].headers.authorization).to.equal('Bearer token');
+        expect(http2Mocker.requests[0].headers['content-type']).to.contain('application/json');
+        expect(http2Mocker.requests[0].headers['My-Custom-Header']).to.equal('CustomValue');
+      });
+
+    await http2SessionHandler.invoke().should.eventually.be.rejectedWith(sessionError)
+  });
 });
 
 describe('AuthorizedHttpClient', () => {