Add e2e tests for websockets

.github/workflows/check-sdk-version.yaml

@@ -0,0 +1,20 @@
+name: Test - Check SDK version
+
+on:
+  pull_request
+
+jobs:
+  check-sdk-version:
+      runs-on: ubuntu-20.04
+
+      steps:
+          - name: 🏗 Setup repo
+            uses: actions/checkout@v3
+
+          - name: 📦 Check it is using the latest version of the SDK
+            uses: actions/setup-node@v3
+            with:
+                node-version: 18.12.1
+          - run: corepack enable
+          - run: yarn install --immutable
+          - run: yarn run updateSdkVersion $GITHUB_BASE_REF check

README.md

@@ -10,12 +10,6 @@
 yarn install
 ```
 
-For the `development` branch
-
-```bash
-yarn add @tonomy/tonomy-id-sdk@development
-```
-
 ## Running the app
 
 ```bash
@@ -29,6 +23,14 @@ yarn run start:dev
 yarn run start:prod
 ```
 
+## Update the Tonomy-ID-SDK version to the latest
+
+```bash
+yarn run updateSdkVersion development
+# or
+yarn run updateSdkVersion master
+```
+
 ## Environment variables and configuration
 
 `NODE_ENV` - Determines which config file in `./src/config` to use

package.json

@@ -17,7 +17,8 @@
     "test:watch": "jest --watch",
     "test:cov": "jest --coverage",
     "test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/.bin/jest --runInBand",
-    "test:e2e": "jest --config ./test/jest-e2e.json"
+    "test:e2e": "jest --config ./test/jest-e2e.json",
+    "updateSdkVersion": "./update_sdk_version.sh"
   },
   "dependencies": {
     "@nestjs/common": "^10.2.3",
@@ -27,7 +28,7 @@
     "@nestjs/platform-socket.io": "^10.2.3",
     "@nestjs/swagger": "^7.1.10",
     "@nestjs/websockets": "^10.2.3",
-    "@tonomy/tonomy-id-sdk": "^0.15.0-development.2",
+    "@tonomy/tonomy-id-sdk": "0.15.0-development.3",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.14.0",
     "hcaptcha": "^0.1.1",

src/communication/communication.gateway.ts

@@ -16,11 +16,17 @@
   UsePipes,
 } from '@nestjs/common';
 import { TransformVcPipe } from './transform-vc/transform-vc.pipe';
-import { MessageDto, MessageRto } from './dto/message.dto';
 import { Client } from './dto/client.dto';
 import { WsExceptionFilter } from './ws-exception/ws-exception.filter';
 import { AuthenticationMessage } from '@tonomy/tonomy-id-sdk';
 import { CommunicationGuard } from './communication.guard';
+import { BodyDto } from './dto/body.dto';
+
+export type WebsocketReturnType = {
+  status: HttpStatus;
+  details?: any;
+  error?: any;
+};
 
 @UseFilters(WsExceptionFilter)
 @UsePipes(new TransformVcPipe())
@@ -39,38 +45,58 @@
   /**
    * Logs in the user and added it to the loggedIn map
    *
-   * @param {MessageDto} message - the VC the user sent
+   * @param {BodyDto} body - The message VC or an error from the transformer
    * @param {Client} client - user socket
-   * @returns void
    */
   @SubscribeMessage('login')
-  connectUser(
-    @MessageBody() message: MessageDto,
+  async connectUser(
+    @MessageBody() body: BodyDto,
     @ConnectedSocket() client: Client,
   ) {
-    if (message.getType() !== AuthenticationMessage.getType()) {
-      throw new HttpException(
-        "Message type must be 'AuthenticationMessage'",
-        HttpStatus.BAD_REQUEST,
-      );
-    }
+    try {
+      if (body.error) throw body.error;
+      if (!body.value) throw new Error('Body not found');
+      const message = body.value;
+
+      if (message.getType() !== AuthenticationMessage.getType()) {
+        throw new HttpException(
+          "Message type must be 'AuthenticationMessage'",
+          HttpStatus.BAD_REQUEST,
+        );
+      }
 
-    return this.usersService.login(message.getSender(), client);
+      return {
+        status: HttpStatus.OK,
+        details: await this.usersService.login(message.getSender(), client),
+      };
+    } catch (e) {
+      return this.usersService.handleError(e);
+    }
   }
 
   /**
    * sends the message to the VC recipient if is connected and loggedIn
-   * @param message the VC the user sent
+   * @param {BodyDto} body - The message VC or an error from the transformer
    * @param client user socket
-   * @returns void
    */
   @SubscribeMessage('message')
   @UseGuards(CommunicationGuard)
-  relayMessage(
-    @MessageBody() message: MessageDto,
+  async relayMessage(
+    @MessageBody() body: BodyDto,
     @ConnectedSocket() client: Client,
   ) {
-    return this.usersService.sendMessage(client, message);
+    try {
+      if (body.error) throw body.error;
+      if (!body.value) throw new Error('Body not found');
+      const message = body.value;
+
+      return {
+        status: HttpStatus.OK,
+        details: await this.usersService.sendMessage(client, message),
+      };
+    } catch (e) {
+      return this.usersService.handleError(e);
+    }
   }
 
   /**

src/communication/communication.service.ts

@@ -3,6 +3,7 @@
 import { Client } from './dto/client.dto';
 import { MessageDto } from './dto/message.dto';
 import settings from '../settings';
+import { WebsocketReturnType } from './communication.gateway';
 
 @Injectable()
 export class CommunicationService {
@@ -67,4 +68,21 @@
 
     return true;
   }
+
+  handleError(e): WebsocketReturnType {
+    if (settings.env !== 'test') console.error(e);
+    // this.logger.error(e); // This does not print stack trace
+
+    if (e instanceof HttpException) {
+      return {
+        status: e.getStatus(),
+        error: e.getResponse(),
+      };
+    }
+
+    return {
+      status: HttpStatus.INTERNAL_SERVER_ERROR,
+      error: e.message,
+    };
+  }
 }

src/communication/dto/body.dto.ts

@@ -0,0 +1,6 @@
+import { MessageDto } from './message.dto';
+
+export type BodyDto = {
+    value?: MessageDto;
+    error?: any;
+};

src/communication/transform-vc/transform-vc.pipe.ts

@@ -6,42 +6,53 @@ import {
   PipeTransform,
 } from '@nestjs/common';
 import { MessageDto, MessageRto } from '../dto/message.dto';
+import { BodyDto } from '../dto/body.dto';
 
 @Injectable()
 export class TransformVcPipe implements PipeTransform {
-  async transform(value: MessageRto, metadata: ArgumentMetadata) {
-    if (metadata.type === 'body') {
-      const message = new MessageDto(value.message);
+  async transform(
+    value: MessageRto,
+    metadata: ArgumentMetadata,
+  ): Promise<BodyDto | MessageRto> {
+    try {
+      if (metadata.type === 'body') {
+        const message = new MessageDto(value.message);
 
-      try {
-        const result = await message.verify();
+        try {
+          const result = await message.verify();
 
-        if (!result)
-          throw new HttpException(
-            `VC not could not verify signer from ${message.getSender()}`,
-            HttpStatus.UNAUTHORIZED,
-          );
-        return message;
-      } catch (e) {
-        if (
-          e.message?.startsWith(
-            'resolver_error: Unable to resolve DID document for',
-          )
-        ) {
-          throw new HttpException(
-            `DID could not be resolved from ${message.getSender()}`,
-            HttpStatus.NOT_FOUND,
-          );
-        }
+          if (!result)
+            throw new HttpException(
+              `VC not could not verify signer from ${message.getSender()}`,
+              HttpStatus.UNAUTHORIZED,
+            );
+          return { value: message };
+        } catch (e) {
+          if (
+            e.message?.startsWith(
+              'resolver_error: Unable to resolve DID document for',
+            )
+          ) {
+            throw new HttpException(
+              `DID could not be resolved from ${message.getSender()}`,
+              HttpStatus.NOT_FOUND,
+            );
+          }
 
-        if (e instanceof HttpException) {
-          throw e;
-        }
+          if (e instanceof HttpException) {
+            throw e;
+          }
 
-        throw new HttpException(e, HttpStatus.INTERNAL_SERVER_ERROR);
+          throw new HttpException(e, HttpStatus.INTERNAL_SERVER_ERROR);
+        }
+      } else {
+        // Do nothing. transform() is not needed
+        return value;
       }
+    } catch (e) {
+      return {
+        error: e,
+      };
     }
-
-    return value;
   }
 }

src/settings.ts

@@ -5,7 +5,7 @@
 
 const env = process.env.NODE_ENV || 'development';
 
-console.log(`NODE_ENV=${env}`);
+if (env !== 'test') console.log(`NODE_ENV=${env}`);
 
 type ConfigType = {
   blockchainUrl: string;
@@ -69,12 +69,12 @@
 settings.config = Object.assign({}, config);
 
 if (process.env.BLOCKCHAIN_URL) {
   console.log(`Using BLOCKCHAIN_URL from env:  ${process.env.BLOCKCHAIN_URL}`);
 
   settings.config.blockchainUrl = process.env.BLOCKCHAIN_URL;
 }
 
-console.log('settings', settings);
+if (env !== 'test') console.log('settings', settings);
 
 settings.secrets = {
   createAccountPrivateKey: EosioUtil.defaultAntelopePrivateKey.toString(),

test/communication.e2e-spec.ts

@@ -0,0 +1,68 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { INestApplication } from '@nestjs/common';
+import { AppModule } from '../src/app.module';
+import { connectSocket, emitMessage } from './ws-client.helper';
+import { Socket } from 'socket.io-client';
+import {
+    AuthenticationMessage,
+    ES256KSigner,
+    generateRandomKeyPair,
+    setSettings,
+} from '@tonomy/tonomy-id-sdk';
+// @ts-expect-error - cannot find module or its corresponding type declarations
+import { createJWK, toDid } from '@tonomy/tonomy-id-sdk/util';
+
+setSettings({
+    blockchainUrl: 'http://localhost:8888',
+});
+
+describe('CommunicationGateway (e2e)', () => {
+    let app: INestApplication;
+    let socket: Socket;
+
+    beforeEach(async () => {
+        const moduleFixture: TestingModule = await Test.createTestingModule({
+            imports: [AppModule],
+        }).compile();
+
+        app = moduleFixture.createNestApplication();
+        app.listen(5000);
+
+        socket = await connectSocket();
+    });
+
+    afterEach(async () => {
+        await socket.disconnect();
+        await socket.close();
+        await app.close();
+    });
+
+    describe('login event', () => {
+        it('fails when provide an empty body', async () => {
+            await expect(() => emitMessage(socket, 'login', {})).rejects.toThrow(
+                "Cannot read properties of undefined (reading 'getCredentialSubject')",
+            );
+        });
+
+        it('succeeds for did:jwk message', async () => {
+            const { privateKey, publicKey } = generateRandomKeyPair();
+            const signer = ES256KSigner(privateKey.data.array, true);
+            const jwk = await createJWK(publicKey);
+            const did = toDid(jwk);
+
+            const issuer = {
+                did,
+                signer,
+                alg: 'ES256K-R',
+            };
+            const message = await AuthenticationMessage.signMessageWithoutRecipient(
+                { data: 'test' },
+                issuer,
+            );
+
+            const response = await emitMessage(socket, 'login', { message });
+
+            expect(response).toBeTruthy();
+        });
+    });
+});