E2E test added to support advanced GRPC + Protobuf case

Author: anton-alation

integration/microservices/e2e/orders-grpc.spec.ts

@@ -0,0 +1,132 @@
+import { INestApplication } from '@nestjs/common';
+import { Transport } from '@nestjs/microservices';
+import { Test } from '@nestjs/testing';
+import * as express from 'express';
+import { join } from 'path';
+import * as request from 'supertest';
+import * as ProtoLoader from '@grpc/proto-loader';
+import * as GRPC from 'grpc';
+import { expect } from 'chai';
+import { fail } from 'assert';
+import { AdvancedGrpcController } from '../src/grpc-advanced/advanced.grpc.controller';
+
+describe('Advanced GRPC transport', () => {
+  let server;
+  let app: INestApplication;
+  let client: any;
+
+  before(async () => {
+    const module = await Test.createTestingModule({
+      controllers: [AdvancedGrpcController],
+    }).compile();
+    // Create gRPC + HTTP server
+    server = express();
+    app = module.createNestApplication(server);
+    /*
+     *  Create microservice configuration
+     */
+    app.connectMicroservice({
+      transport: Transport.GRPC,
+      options: {
+        package: 'proto_example',
+        protoPath: 'root.proto',
+        loader: {
+          includeDirs: [join(__dirname, '../src/grpc-advanced/proto')],
+          keepCase: true,
+        },
+      },
+    });
+    // Start gRPC microservice
+    await app.startAllMicroservicesAsync();
+    await app.init();
+    // Load proto-buffers for test gRPC dispatch
+    const proto = ProtoLoader.loadSync('root.proto', {
+        includeDirs: [join(__dirname, '../src/grpc-advanced/proto')],
+    }) as any;
+    // Create Raw gRPC client object
+    const protoGRPC = GRPC.loadPackageDefinition(proto) as any;
+    // Create client connected to started services at standard 5000 port
+    client = new protoGRPC.proto_example.orders.OrderService(
+      'localhost:5000',
+      GRPC.credentials.createInsecure(),
+    );
+
+  });
+
+  it(`GRPC Sending and Receiving HTTP POST`, () => {
+    return request(server)
+      .post('/')
+      .send('1')
+      .expect(200, {
+        id: 1,
+        itemTypes: [1],
+        shipmentType: {
+          from: 'test',
+          to: 'test1',
+          carrier: 'test-carrier',
+        },
+      });
+  });
+
+  it('GRPC Sending and receiving message', async () => {
+
+    // Execute find in Promise
+    return new Promise(resolve => {
+      client.find({
+        id: 1,
+      }, (err, result) => {
+        // Compare results
+        expect(err).to.be.null;
+        expect(result).to.eql({
+          id: 1,
+          itemTypes: [1],
+          shipmentType: {
+            from: 'test',
+            to: 'test1',
+            carrier: 'test-carrier',
+          },
+        });
+        // Resolve after checkups
+        resolve();
+      });
+
+    });
+
+  });
+
+  it('GRPC Sending and receiving Stream from RX handler', async () => {
+
+    const callHandler = client.sync();
+
+    callHandler.on('data', (msg: number) => {
+      // Do deep comparison (to.eql)
+      expect(msg).to.eql({
+        id: 1,
+        itemTypes: [1],
+        shipmentType: {
+          from: 'test',
+          to: 'test1',
+          carrier: 'test-carrier',
+        },
+      });
+      callHandler.cancel();
+    });
+
+    callHandler.on('error', (err: any) => {
+      // We want to fail only on real errors while Cancellation error
+      // is expected
+      if (String(err).toLowerCase().indexOf('cancelled') === -1) {
+        fail('gRPC Stream error happened, error: ' + err);
+      }
+    });
+
+    return new Promise((resolve, reject) => {
+      callHandler.write({
+        id: 1,
+      });
+      setTimeout(() => resolve(), 1000);
+    });
+
+  });
+
+});