convert to jest

Author: Thomas Belin

packages/api-client/babel.config.js

@@ -18,10 +18,5 @@
  */
 
 module.exports = {
-  plugins: [
-    '@babel/plugin-proposal-optional-chaining',
-    '@babel/plugin-proposal-class-properties',
-    '@babel/plugin-proposal-object-rest-spread',
-  ],
-  presets: ['@babel/preset-react', '@babel/preset-typescript'],
+  presets: [['@babel/preset-env', {targets: {node: 'current'}}], '@babel/preset-typescript'],
 };

packages/api-client/jest.config.ts

@@ -0,0 +1,25 @@
+/*
+ * Wire
+ * Copyright (C) 2022 Wire Swiss GmbH
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see http://www.gnu.org/licenses/.
+ *
+ */
+
+
+export default {
+  clearMocks: true,
+  testMatch: ['**/?(*.)+(spec|test).node.[t]s?(x)'],
+  coverageDirectory: 'coverage',
+};

packages/api-client/package.json

@@ -21,9 +21,12 @@
     "@babel/plugin-proposal-class-properties": "7.14.5",
     "@babel/plugin-proposal-object-rest-spread": "7.14.7",
     "@babel/plugin-proposal-optional-chaining": "7.14.5",
+    "@babel/preset-env": "^7.19.1",
     "@babel/preset-react": "7.14.5",
     "@babel/preset-typescript": "7.14.5",
+    "@types/babel__preset-env": "^7",
     "@types/jasmine": "3.8.2",
+    "@types/jest": "^29.0.3",
     "@types/karma": "6.3.3",
     "@types/node": "^14.18.29",
     "@types/spark-md5": "3.0.2",

packages/api-client/src/APIClient.test.node.ts

@@ -281,10 +281,10 @@ describe('APIClient', () => {
       const client = new APIClient();
       const testError = new Error('Test rejection');
 
-      spyOn(client.api.auth, 'postLogout').and.returnValue(Promise.reject(testError));
-      spyOn(client, 'disconnect').and.returnValue();
-      spyOn(client['accessTokenStore'], 'delete').and.returnValue(Promise.resolve(undefined));
-      spyOn(client['logger'], 'warn').and.returnValue();
+      jest.spyOn(client.api.auth, 'postLogout').mockReturnValue(Promise.reject(testError));
+      jest.spyOn(client, 'disconnect').mockReturnValue();
+      jest.spyOn(client['accessTokenStore'], 'delete').mockReturnValue(Promise.resolve(undefined));
+      jest.spyOn(client['logger'], 'warn').mockReturnValue();
 
       await client.logout();
       expect(client['logger'].warn).toHaveBeenCalledWith(testError);
@@ -293,10 +293,10 @@ describe('APIClient', () => {
     it('skips request when told to', async () => {
       const client = new APIClient();
 
-      spyOn(client.api.auth, 'postLogout');
-      spyOn(client, 'disconnect').and.returnValue();
-      spyOn(client['accessTokenStore'], 'delete').and.returnValue(Promise.resolve(undefined));
-      spyOn(client['logger'], 'warn').and.returnValue();
+      jest.spyOn(client.api.auth, 'postLogout');
+      jest.spyOn(client, 'disconnect').mockReturnValue();
+      jest.spyOn(client['accessTokenStore'], 'delete').mockReturnValue(Promise.resolve(undefined));
+      jest.spyOn(client['logger'], 'warn').mockReturnValue();
 
       await client.logout({skipLogoutRequest: true});
       expect(client['logger'].warn).not.toHaveBeenCalled();

packages/api-client/src/asset/AssetAPI.test.node.ts

@@ -24,7 +24,7 @@ describe('"AssetAPI"', () => {
   const apiClient = new APIClient();
 
   it('adds token parameters', async () => {
-    spyOn(apiClient.transport.http, 'sendRequest').and.returnValue(
+    jest.spyOn(apiClient.transport.http, 'sendRequest').mockReturnValue(
       Promise.resolve({
         config: {},
         data: '',
@@ -39,18 +39,18 @@ describe('"AssetAPI"', () => {
     await apiClient.api.asset.getAssetV3(assetId, assetToken);
 
     expect(apiClient.transport.http.sendRequest).toHaveBeenCalledWith(
-      jasmine.objectContaining({
+      expect.objectContaining({
         params: {
           asset_token: assetToken,
         },
-        url: jasmine.stringMatching(new RegExp(assetId)),
+        url: expect.stringMatching(new RegExp(assetId)),
       }),
       true,
     );
   });
 
   it('removes token parameters', async () => {
-    spyOn(apiClient.transport.http, 'sendRequest').and.returnValue(
+    jest.spyOn(apiClient.transport.http, 'sendRequest').mockReturnValue(
       Promise.resolve({
         config: {},
         data: '',
@@ -64,9 +64,9 @@ describe('"AssetAPI"', () => {
     await apiClient.api.asset.getAssetV3(assetId);
 
     expect(apiClient.transport.http.sendRequest).toHaveBeenCalledWith(
-      jasmine.objectContaining({
+      expect.objectContaining({
         params: {},
-        url: jasmine.stringMatching(new RegExp(assetId)),
+        url: expect.stringMatching(new RegExp(assetId)),
       }),
       true,
     );

packages/api-client/src/auth/AuthAPI.test.node.ts

@@ -31,7 +31,7 @@ describe('AuthAPI', () => {
       password: '[email protected]',
     };
 
-    spyOn(apiClient.transport.http, 'sendJSON').and.returnValue(
+    jest.spyOn(apiClient.transport.http, 'sendJSON').mockReturnValue(
       Promise.resolve({
         config: {},
         data: '',
@@ -44,7 +44,7 @@ describe('AuthAPI', () => {
     await apiClient.api.auth.postLogin(data);
 
     expect(apiClient.transport.http.sendJSON).toHaveBeenCalledWith(
-      jasmine.objectContaining({
+      expect.objectContaining({
         data: {
           clientType: undefined,
           email: data.email,
@@ -64,7 +64,7 @@ describe('AuthAPI', () => {
       password: '[email protected]',
     };
 
-    spyOn(apiClient.transport.http, 'sendJSON').and.returnValue(
+    jest.spyOn(apiClient.transport.http, 'sendJSON').mockReturnValue(
       Promise.resolve({
         config: {},
         data: '',
@@ -77,7 +77,7 @@ describe('AuthAPI', () => {
     await apiClient.api.auth.postLogin(data);
 
     expect(apiClient.transport.http.sendJSON).toHaveBeenCalledWith(
-      jasmine.objectContaining({
+      expect.objectContaining({
         data: {
           clientType: undefined,
           email: data.email,

packages/api-client/src/conversation/ConversationAPI/ConversationAPI.test.ts

@@ -32,21 +32,21 @@ describe('ConversationAPI', () => {
     it('add ignore_missing and report_missing parameters', async () => {
       await conversationApi.postOTRMessage('client-id', 'conv-id', undefined, false);
       expect(httpClientMock.sendJSON).toHaveBeenCalledWith(
-        jasmine.objectContaining({
+        expect.objectContaining({
           params: {ignore_missing: false},
         }),
         true,
       );
 
       await conversationApi.postOTRMessage('client-id', 'conv-id', undefined, true);
       expect(httpClientMock.sendJSON).toHaveBeenCalledWith(
-        jasmine.objectContaining({params: {ignore_missing: true}}),
+        expect.objectContaining({params: {ignore_missing: true}}),
         true,
       );
 
       await conversationApi.postOTRMessage('client-id', 'conv-id', undefined, ['user1', 'user2']);
       expect(httpClientMock.sendJSON).toHaveBeenCalledWith(
-        jasmine.objectContaining({
+        expect.objectContaining({
           params: {ignore_missing: 'user1,user2'},
         }),
         true,

packages/api-client/src/http/BackendErrorMapper.test.node.ts

@@ -34,7 +34,7 @@ describe('BackendErrorMapper', () => {
       };
 
       const userError = BackendErrorMapper.map(userIdError);
-      expect(userError).toEqual(jasmine.any(UserIsUnknownError));
+      expect(userError).toEqual(expect.any(UserIsUnknownError));
 
       const conversationIdError = {
         code: StatusCode.BAD_REQUEST,
@@ -44,7 +44,7 @@ describe('BackendErrorMapper', () => {
       };
 
       const conversationError = BackendErrorMapper.map(conversationIdError);
-      expect(conversationError).toEqual(jasmine.any(ConversationIsUnknownError));
+      expect(conversationError).toEqual(expect.any(ConversationIsUnknownError));
     });
   });
 });

packages/api-client/src/tcp/ReconnectingWebsocket.test.node.ts

@@ -90,10 +90,10 @@ describe('ReconnectingWebsocket', () => {
   });
 
   it('calls "onReconnect", "onOpen" and "onClose"', done => {
-    const onReconnect = jasmine.createSpy().and.returnValue(getServerAddress());
+    const onReconnect = jest.fn().mockReturnValue(getServerAddress());
     const RWS = new ReconnectingWebsocket(onReconnect);
     RWS.setOnOpen(() => {
-      expect(onReconnect.calls.count()).toBe(1);
+      expect(onReconnect).toHaveBeenCalledTimes(1);
       RWS.disconnect();
     });
     RWS.setOnClose(event => {
@@ -104,15 +104,15 @@ describe('ReconnectingWebsocket', () => {
   });
 
   it('closes the connection without reconnecting when server terminates the connection', done => {
-    const onReconnect = jasmine.createSpy().and.returnValue(getServerAddress());
+    const onReconnect = jest.fn().mockReturnValue(getServerAddress());
     const RWS = new ReconnectingWebsocket(onReconnect);
     RWS.setOnOpen(() => {
-      expect(onReconnect.calls.count()).toBe(1);
+      expect(onReconnect).toHaveBeenCalledTimes(1);
       RWS.send('terminate');
     });
     RWS.setOnClose(event => {
       expect(event.wasClean).toBe(true);
-      expect(onReconnect.calls.count()).toBe(1);
+      expect(onReconnect).toHaveBeenCalledTimes(1);
       done();
     });
     RWS.connect();
@@ -124,14 +124,14 @@ describe('ReconnectingWebsocket', () => {
    */
   it('reconnects', done => {
     let reconnectCalls = 0;
-    const onReconnect = jasmine.createSpy().and.returnValue(getServerAddress());
+    const onReconnect = jest.fn().mockReturnValue(getServerAddress());
     const RWS = new ReconnectingWebsocket(onReconnect);
 
     RWS.connect();
 
     RWS.setOnOpen(() => {
       reconnectCalls++;
-      expect(onReconnect.calls.count()).toBe(reconnectCalls);
+      expect(onReconnect).toHaveBeenCalledTimes(reconnectCalls);
       if (reconnectCalls === 1) {
         RWS['socket']!.reconnect();
       } else {

packages/api-client/src/tcp/WebSocketClient.test.node.ts

@@ -59,76 +59,76 @@ describe('WebSocketClient', () => {
   describe('handler', () => {
     it('calls "onOpen" when WebSocket opens', async () => {
       const websocketClient = new WebSocketClient('url', fakeHttpClient);
-      const onOpenSpy = spyOn<any>(websocketClient, 'onOpen').and.callThrough();
+      const onOpenSpy = jest.spyOn(websocketClient as any, 'onOpen');
       const socket = websocketClient['socket'];
-      spyOn<any>(socket, 'getReconnectingWebsocket').and.returnValue(fakeSocket);
+      jest.spyOn(socket as any, 'getReconnectingWebsocket').mockReturnValue(fakeSocket);
 
       await websocketClient.connect();
       fakeSocket.onopen();
 
-      expect(onOpenSpy.calls.count()).toBe(1);
+      expect(onOpenSpy).toHaveBeenCalledTimes(1);
     });
 
     it('calls "onClose" when WebSocket closes', async () => {
       const websocketClient = new WebSocketClient('url', fakeHttpClient);
-      const onCloseSpy = spyOn<any>(websocketClient, 'onClose').and.callThrough();
+      const onCloseSpy = jest.spyOn(websocketClient as any, 'onClose');
       const socket = websocketClient['socket'];
-      spyOn<any>(socket, 'getReconnectingWebsocket').and.returnValue(fakeSocket);
+      jest.spyOn(socket as any, 'getReconnectingWebsocket').mockReturnValue(fakeSocket);
 
       await websocketClient.connect();
       fakeSocket.onclose();
 
-      expect(onCloseSpy.calls.count()).toBe(1);
+      expect(onCloseSpy).toHaveBeenCalledTimes(1);
     });
 
     it('calls "onError" when WebSocket received error', async () => {
       const websocketClient = new WebSocketClient('url', fakeHttpClient);
-      const onErrorSpy = spyOn<any>(websocketClient, 'onError').and.callThrough();
-      const refreshTokenSpy = spyOn<any>(websocketClient, 'refreshAccessToken').and.callThrough();
+      const onErrorSpy = jest.spyOn(websocketClient as any, 'onError');
+      const refreshTokenSpy = jest.spyOn(websocketClient as any, 'refreshAccessToken');
       const socket = websocketClient['socket'];
-      spyOn<any>(socket, 'getReconnectingWebsocket').and.returnValue(fakeSocket);
+      jest.spyOn(socket as any, 'getReconnectingWebsocket').mockReturnValue(fakeSocket);
 
       await websocketClient.connect();
       fakeSocket.onerror(new Error('error'));
 
-      expect(onErrorSpy.calls.count()).toBe(1);
-      expect(refreshTokenSpy.calls.count()).toBe(1);
+      expect(onErrorSpy).toHaveBeenCalledTimes(1);
+      expect(refreshTokenSpy).toHaveBeenCalledTimes(1);
     });
 
     it('calls "onMessage" when WebSocket received message', async () => {
       const message = 'hello';
       const websocketClient = new WebSocketClient('url', fakeHttpClient);
-      const onMessageSpy = spyOn<any>(websocketClient, 'onMessage').and.callThrough();
+      const onMessageSpy = jest.spyOn(websocketClient as any, 'onMessage');
       const socket = websocketClient['socket'];
-      spyOn<any>(socket, 'getReconnectingWebsocket').and.returnValue(fakeSocket);
+      jest.spyOn(socket as any, 'getReconnectingWebsocket').mockReturnValue(fakeSocket);
 
       await websocketClient.connect();
       fakeSocket.onmessage({data: Buffer.from(JSON.stringify({message}), 'utf-8')});
 
-      expect(onMessageSpy.calls.count()).toBe(1);
+      expect(onMessageSpy).toHaveBeenCalledTimes(1);
     });
 
-    it('calls "onConnect" when websocket is connected or re-connected', async () => {
-      const onConnectResult = jasmine.createSpy().and.returnValue(Promise.resolve());
+    it('calls "onConnect" when "onReconnect" is called', async () => {
+      const onConnectResult = jest.fn().mockReturnValue(Promise.resolve());
       const onConnect = () => {
         return onConnectResult();
       };
       const websocketClient = new WebSocketClient('url', fakeHttpClient);
       const socket = websocketClient['socket'];
-      spyOn<any>(socket, 'getReconnectingWebsocket').and.returnValue(fakeSocket);
+      jest.spyOn(socket as any, 'getReconnectingWebsocket').mockReturnValue(fakeSocket);
 
       await websocketClient.connect(undefined, onConnect);
       fakeSocket.onopen();
       await websocketClient['onReconnect']();
-      expect(onConnectResult.calls.count()).toBe(1);
+      expect(onConnectResult).toHaveBeenCalledTimes(1);
     });
   });
 
   describe('refreshAccessToken', () => {
     it('emits the correct message for invalid tokens', async done => {
       const websocketClient = new WebSocketClient('url', invalidTokenHttpClient);
       const socket = websocketClient['socket'];
-      spyOn<any>(socket, 'getReconnectingWebsocket').and.returnValue(fakeSocket);
+      jest.spyOn(socket as any, 'getReconnectingWebsocket').mockReturnValue(fakeSocket);
 
       await websocketClient.connect();
 
@@ -155,15 +155,15 @@ describe('WebSocketClient', () => {
 
     it('does not lock websocket by default', async done => {
       const websocketClient = new WebSocketClient('url', fakeHttpClient);
-      const onMessageSpy = spyOn<any>(websocketClient, 'onMessage').and.callThrough();
+      const onMessageSpy = jest.spyOn(websocketClient as any, 'onMessage');
       const socket = websocketClient['socket'];
-      spyOn<any>(socket, 'getReconnectingWebsocket').and.returnValue(fakeSocket);
+      jest.spyOn(socket as any, 'getReconnectingWebsocket').mockReturnValue(fakeSocket);
 
       await websocketClient.connect();
       expect(websocketClient.isLocked()).toBe(false);
 
       websocketClient.on(WebSocketClient.TOPIC.ON_MESSAGE, notification => {
-        expect(onMessageSpy.calls.count()).toBe(1);
+        expect(onMessageSpy).toHaveBeenCalledTimes(1);
         expect(websocketClient['bufferedMessages'].length).toBe(0);
         expect(notification).toEqual(fakeNotification);
         done();
@@ -173,21 +173,21 @@ describe('WebSocketClient', () => {
 
     it('emits buffered messages when unlocked', async done => {
       const websocketClient = new WebSocketClient('url', fakeHttpClient);
-      const onMessageSpy = spyOn<any>(websocketClient, 'onMessage').and.callThrough();
+      const onMessageSpy = jest.spyOn(websocketClient as any, 'onMessage');
       const socket = websocketClient['socket'];
-      spyOn<any>(socket, 'getReconnectingWebsocket').and.returnValue(fakeSocket);
+      jest.spyOn(socket as any, 'getReconnectingWebsocket').mockReturnValue(fakeSocket);
 
       websocketClient.lock();
       await websocketClient.connect();
       expect(websocketClient.isLocked()).toBe(true);
 
       fakeSocket.onmessage({data: Buffer.from(JSON.stringify(fakeNotification), 'utf-8')});
-      expect(onMessageSpy.calls.count()).toBe(1);
+      expect(onMessageSpy).toHaveBeenCalledTimes(1);
       expect(websocketClient['bufferedMessages'].length).toBe(1);
 
       websocketClient.on(WebSocketClient.TOPIC.ON_MESSAGE, notification => {
         expect(notification).toEqual(notification);
-        expect(onMessageSpy.calls.count()).toBe(2);
+        expect(onMessageSpy).toHaveBeenCalledTimes(2);
         done();
       });