test: add e2e tests

tests/e2e/scoped-env-gc-pubsub.spec.ts

@@ -0,0 +1,60 @@
+import { INestApplication } from '@nestjs/common';
+import { Test } from '@nestjs/testing';
+import { expect } from 'chai';
+import * as request from 'supertest';
+import { GCPubSubServer } from '../../lib';
+import {
+  GCPubSubScopedEnvController1,
+  GCPubSubScopedEnvController2,
+} from '../src/gc-pubsub-scoped-env.controller';
+
+describe('GC PubSub transport', () => {
+  let server;
+  let app: INestApplication;
+
+  describe('useAttributes=false', () => {
+    beforeEach(async () => {
+      await Test.createTestingModule({
+        controllers: [GCPubSubScopedEnvController2],
+      }).compile();
+      const module = await Test.createTestingModule({
+        controllers: [GCPubSubScopedEnvController1],
+      }).compile();
+
+      app = module.createNestApplication();
+      server = app.getHttpAdapter().getInstance();
+
+      app.connectMicroservice({
+        strategy: new GCPubSubServer({
+          client: {
+            apiEndpoint: 'localhost:8681',
+            projectId: 'microservice',
+          },
+          scopedEnvKey: 'foobar',
+        }),
+      });
+      await app.startAllMicroservices();
+      await app.init();
+    });
+
+    it('/POST', () => {
+      request(server).post('/rpc').expect(200, 'scoped RPC');
+    });
+
+    it('/POST (event notification)', (done) => {
+      request(server)
+        .post('/notify')
+        .end(() => {
+          setTimeout(() => {
+            expect(GCPubSubScopedEnvController1.IS_NOTIFIED).to.be.true;
+            expect(GCPubSubScopedEnvController2.IS_NOTIFIED).to.be.false;
+            done();
+          }, 1000);
+        });
+    });
+
+    afterEach(async () => {
+      await app.close();
+    });
+  });
+});

tests/src/gc-pubsub-scoped-env.controller.ts

@@ -0,0 +1,92 @@
+import {
+  Controller,
+  HttpCode,
+  OnApplicationShutdown,
+  Post,
+} from '@nestjs/common';
+import {
+  ClientProxy,
+  EventPattern,
+  MessagePattern,
+} from '@nestjs/microservices';
+import { GCPubSubClient } from '../../lib';
+import { Observable } from 'rxjs';
+
+@Controller()
+export class GCPubSubScopedEnvController1 implements OnApplicationShutdown {
+  static IS_NOTIFIED = false;
+
+  client: ClientProxy;
+
+  constructor() {
+    this.client = new GCPubSubClient({
+      client: {
+        apiEndpoint: 'localhost:8681',
+        projectId: 'microservice',
+      },
+      replyTopic: 'default_reply_topic',
+      replySubscription: 'default_reply_subscription',
+      scopedEnvKey: 'foobar',
+    });
+  }
+
+  onApplicationShutdown(signal?: string) {
+    return this.client.close();
+  }
+
+  @Post()
+  @HttpCode(200)
+  call() {
+    return this.client.send({ cmd: 'rpc' }, {});
+  }
+
+  @Post('notify')
+  async sendNotification(): Promise<any> {
+    return this.client.emit<{ notification: boolean; id: string }>(
+      'notification',
+      { notification: true, id: 'id' },
+    );
+  }
+
+  @MessagePattern({ cmd: 'rpc' })
+  rpc(): string {
+    return 'scoped RPC';
+  }
+
+  @EventPattern('notification')
+  eventHandler(data: { notification: boolean; id: string }) {
+    GCPubSubScopedEnvController1.IS_NOTIFIED = data.notification;
+  }
+}
+
+@Controller()
+export class GCPubSubScopedEnvController2 implements OnApplicationShutdown {
+  static IS_NOTIFIED = false;
+
+  client: ClientProxy;
+
+  constructor() {
+    this.client = new GCPubSubClient({
+      client: {
+        apiEndpoint: 'localhost:8681',
+        projectId: 'microservice',
+      },
+      replyTopic: 'default_reply_topic',
+      replySubscription: 'default_reply_subscription',
+    });
+  }
+
+  onApplicationShutdown(signal?: string) {
+    return this.client.close();
+  }
+
+  @MessagePattern({ cmd: 'rpc' })
+  rpc(): string {
+    return 'RPC';
+  }
+
+  @EventPattern('notification')
+  eventHandler(data: { notification: boolean; id: string }) {
+    GCPubSubScopedEnvController2.IS_NOTIFIED = data.notification;
+  }
+}