refactor(jest-worker): convert part of test into TypeScript (#13441)

Author: mrazauskas

packages/jest-worker/src/__tests__/Farm.test.js renamed to packages/jest-worker/src/__tests__/Farm.test.ts

@@ -5,42 +5,59 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-'use strict';
-
 import Farm from '../Farm';
-
-let mockWorkerCalls;
-let callback;
-
-function workerReplyStart(i) {
-  mockWorkerCalls[i].onStart({getWorkerId: () => mockWorkerCalls[i].workerId});
+import type {
+  ChildMessage,
+  OnCustomMessage,
+  OnEnd,
+  OnStart,
+  WorkerCallback,
+  WorkerInterface,
+} from '../types';
+
+let mockWorkerCalls: Array<{
+  onCustomMessage: OnCustomMessage;
+  onEnd: OnEnd;
+  onStart: OnStart;
+  passed: ChildMessage;
+  workerId: number;
+}>;
+
+let callback: WorkerCallback;
+
+function workerReplyStart(i: number) {
+  mockWorkerCalls[i].onStart({
+    getWorkerId: () => mockWorkerCalls[i].workerId,
+  } as WorkerInterface);
 }
 
-function workerReplyEnd(i, error, result) {
+function workerReplyEnd(i: number, error: Error | null, result?: unknown) {
   mockWorkerCalls[i].onEnd(error, result);
 }
 
-function workerReply(i, error, result) {
+function workerReply(i: number, error: Error | null = null, result?: unknown) {
   workerReplyStart(i);
   workerReplyEnd(i, error, result);
 }
 
-function workerReplyCustomMessage(i, message) {
+function workerReplyCustomMessage(i: number, message: unknown) {
   mockWorkerCalls[i].onCustomMessage(message);
 }
 
 describe('Farm', () => {
   beforeEach(() => {
     mockWorkerCalls = [];
-    callback = jest.fn((...args) => {
-      mockWorkerCalls.push({
-        onCustomMessage: args[4],
-        onEnd: args[3],
-        onStart: args[2],
-        passed: args[1],
-        workerId: args[0],
-      });
-    });
+    callback = jest.fn<WorkerCallback>(
+      (workerId, request, onStart, onEnd, onCustomMessage) => {
+        mockWorkerCalls.push({
+          onCustomMessage,
+          onEnd,
+          onStart,
+          passed: request,
+          workerId,
+        });
+      },
+    );
   });
 
   it('sends a request to one worker', () => {
@@ -127,7 +144,7 @@ describe('Farm', () => {
 
   it('sends the same worker key to the same worker', async () => {
     const computeWorkerKey = jest
-      .fn(() => {})
+      .fn<() => string>()
       .mockReturnValueOnce('one')
       .mockReturnValueOnce('two')
       .mockReturnValueOnce('one');
@@ -296,23 +313,23 @@ describe('Farm', () => {
 
   it('checks that locking works, and jobs are never lost', async () => {
     const hash = jest
-      .fn()
+      .fn<() => string>()
       // This will go to both queues, but picked by the first worker.
-      .mockReturnValueOnce(0)
+      .mockReturnValueOnce('0')
       // This will go to both queues too, but picked by the second worker.
-      .mockReturnValueOnce(1)
-      // This will go to worker 0, now only assigned to it.
-      .mockReturnValueOnce(0)
-      // This will go to worker 1, now only assigned to it.
-      .mockReturnValueOnce(1)
+      .mockReturnValueOnce('1')
+      // This will go to worker '0', now only assigned to it.
+      .mockReturnValueOnce('0')
+      // This will go to worker '1', now only assigned to it.
+      .mockReturnValueOnce('1')
       // This will go to both queues too, but will wait, since workers are busy.
-      .mockReturnValueOnce(2)
+      .mockReturnValueOnce('2')
       // This will only go to the first queue.
-      .mockReturnValueOnce(0)
+      .mockReturnValueOnce('0')
       // This will be gone if the queue implementation is wrong.
-      .mockReturnValueOnce(0)
+      .mockReturnValueOnce('0')
       // Push onto the second queue; potentially wiping the earlier job.
-      .mockReturnValueOnce(1);
+      .mockReturnValueOnce('1');
 
     const farm = new Farm(2, callback, {computeWorkerKey: hash});
 
@@ -364,11 +381,11 @@ describe('Farm', () => {
     const p0 = farm.doWork('work-0');
     const p1 = farm.doWork('work-1');
 
-    const unsubscribe = p0.UNSTABLE_onCustomMessage(message => {
+    const unsubscribe = p0.UNSTABLE_onCustomMessage!(message => {
       expect(message).toEqual({key: 0, message: 'foo'});
     });
 
-    p1.UNSTABLE_onCustomMessage(message => {
+    p1.UNSTABLE_onCustomMessage!(message => {
       expect(message).toEqual({key: 1, message: 'bar'});
     });
 

packages/jest-worker/src/__tests__/FifoQueue.test.js renamed to packages/jest-worker/src/__tests__/FifoQueue.test.ts

@@ -5,10 +5,12 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-'use strict';
-
 import FifoQueue from '../FifoQueue';
-import {CHILD_MESSAGE_CALL} from '../types';
+import {
+  CHILD_MESSAGE_CALL,
+  ChildMessageCall,
+  QueueChildMessage,
+} from '../types';
 
 it('returns the shared tasks in FIFO ordering', () => {
   const queue = new FifoQueue();
@@ -82,8 +84,8 @@ it('maintains global FIFO ordering between worker specific and shared tasks', ()
   expect(queue.dequeue(2)).toBeNull();
 });
 
-function createQueueChildMessage(...args) {
-  const request = [CHILD_MESSAGE_CALL, false, 'test', args];
+function createQueueChildMessage(...args: Array<unknown>): QueueChildMessage {
+  const request: ChildMessageCall = [CHILD_MESSAGE_CALL, false, 'test', args];
 
   return {
     onCustomMessage: () => {},

packages/jest-worker/src/__tests__/PriorityQueue.test.js renamed to packages/jest-worker/src/__tests__/PriorityQueue.test.ts

@@ -5,13 +5,16 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-'use strict';
-
 import PriorityQueue from '../PriorityQueue';
-import {CHILD_MESSAGE_CALL} from '../types';
+import {
+  CHILD_MESSAGE_CALL,
+  ChildMessageCall,
+  QueueChildMessage,
+} from '../types';
 
 it('returns the tasks in order', () => {
-  const computePriority = (_method, task) => task.priority;
+  const computePriority = (_method: string, task: unknown) =>
+    (task as {priority: number}).priority;
   const queue = new PriorityQueue(computePriority);
   const priorities = [10, 3, 4, 8, 2, 9, 7, 1, 2, 6, 5];
 
@@ -36,7 +39,8 @@ it('returns the task with the lowest priority value if inserted in reversed orde
   const mid = createQueueChildMessage({priority: 2});
   const first = createQueueChildMessage({priority: 1});
 
-  const computePriority = (_method, task) => task.priority;
+  const computePriority = (_method: string, task: unknown) =>
+    (task as {priority: number}).priority;
   const queue = new PriorityQueue(computePriority);
 
   queue.enqueue(last, 1);
@@ -54,7 +58,8 @@ it('returns the task with the lowest priority value if inserted in correct order
   const mid = createQueueChildMessage({priority: 2});
   const last = createQueueChildMessage({priority: 3});
 
-  const computePriority = (_method, task) => task.priority;
+  const computePriority = (_method: string, task: unknown) =>
+    (task as {priority: number}).priority;
   const queue = new PriorityQueue(computePriority);
 
   queue.enqueue(last, 1);
@@ -73,7 +78,8 @@ it('uses different queues for each worker', () => {
   const task1Worker2 = createQueueChildMessage({priority: 1});
   const task2Worker2 = createQueueChildMessage({priority: 3});
 
-  const computePriority = (_method, task) => task.priority;
+  const computePriority = (_method: string, task: unknown) =>
+    (task as {priority: number}).priority;
   const queue = new PriorityQueue(computePriority);
 
   queue.enqueue(task2Worker1, 1);
@@ -89,7 +95,8 @@ it('uses different queues for each worker', () => {
 });
 
 it('process task in the global and shared queue in order', () => {
-  const computePriority = (_method, task) => task.priority;
+  const computePriority = (_method: string, task: unknown) =>
+    (task as {priority: number}).priority;
   const queue = new PriorityQueue(computePriority);
 
   const sharedTask1 = createQueueChildMessage({priority: 1});
@@ -116,8 +123,8 @@ it('process task in the global and shared queue in order', () => {
   expect(queue.dequeue(2)).toBeNull();
 });
 
-function createQueueChildMessage(...args) {
-  const request = [CHILD_MESSAGE_CALL, false, 'test', args];
+function createQueueChildMessage(...args: Array<unknown>): QueueChildMessage {
+  const request: ChildMessageCall = [CHILD_MESSAGE_CALL, false, 'test', args];
 
   return {
     onCustomMessage: () => {},

packages/jest-worker/src/__tests__/WorkerPool.test.js renamed to packages/jest-worker/src/__tests__/WorkerPool.test.ts

@@ -6,6 +6,7 @@
  */
 
 import WorkerPool from '../WorkerPool';
+import type {ChildMessage, WorkerPoolOptions} from '../types';
 import ChildProcessWorker from '../workers/ChildProcessWorker';
 import NodeThreadWorker from '../workers/NodeThreadsWorker';
 
@@ -37,8 +38,8 @@ jest.mock('../workers/NodeThreadsWorker', () => {
 
 describe('WorkerPool', () => {
   beforeEach(() => {
-    ChildProcessWorker.mockClear();
-    NodeThreadWorker.mockClear();
+    jest.mocked(ChildProcessWorker).mockClear();
+    jest.mocked(NodeThreadWorker).mockClear();
   });
 
   it('should create a ChildProcessWorker and send to it', () => {
@@ -49,13 +50,14 @@ describe('WorkerPool', () => {
       forkOptions: {},
       maxRetries: 1,
       numWorkers: 1,
-      workerId: 0,
-      workerPath: '/path',
-    });
+    } as WorkerPoolOptions);
 
+    const request = {foo: 'bar'} as unknown as ChildMessage;
     const onStart = () => {};
     const onEnd = () => {};
-    workerPool.send(0, {foo: 'bar'}, onStart, onEnd);
+    const onCustomMessage = () => {};
+
+    workerPool.send(0, request, onStart, onEnd, onCustomMessage);
 
     expect(ChildProcessWorker).toHaveBeenCalledWith({
       forkOptions: {},
@@ -64,11 +66,12 @@ describe('WorkerPool', () => {
       workerPath: '/path',
     });
     expect(NodeThreadWorker).not.toHaveBeenCalled();
+    // @ts-expect-error: Testing internal method
     expect(workerPool._workers[0].send).toHaveBeenCalledWith(
-      {foo: 'bar'},
+      request,
       onStart,
       onEnd,
-      undefined,
+      onCustomMessage,
     );
   });
 
@@ -79,13 +82,14 @@ describe('WorkerPool', () => {
       forkOptions: {},
       maxRetries: 1,
       numWorkers: 1,
-      workerId: 0,
-      workerPath: '/path',
-    });
+    } as WorkerPoolOptions);
 
+    const request = {foo: 'bar'} as unknown as ChildMessage;
     const onStart = () => {};
     const onEnd = () => {};
-    workerPool.send(0, {foo: 'bar'}, onStart, onEnd);
+    const onCustomMessage = () => {};
+
+    workerPool.send(0, request, onStart, onEnd, onCustomMessage);
 
     expect(NodeThreadWorker).toHaveBeenCalledWith({
       forkOptions: {},
@@ -94,11 +98,12 @@ describe('WorkerPool', () => {
       workerPath: '/path',
     });
     expect(ChildProcessWorker).not.toHaveBeenCalled();
+    // @ts-expect-error: Testing internal method
     expect(workerPool._workers[0].send).toHaveBeenCalledWith(
-      {foo: 'bar'},
+      request,
       onStart,
       onEnd,
-      undefined,
+      onCustomMessage,
     );
   });
 
@@ -108,13 +113,14 @@ describe('WorkerPool', () => {
       forkOptions: {},
       maxRetries: 1,
       numWorkers: 1,
-      workerId: 0,
-      workerPath: '/path',
-    });
+    } as WorkerPoolOptions);
 
+    const request = {foo: 'bar'} as unknown as ChildMessage;
     const onStart = () => {};
     const onEnd = () => {};
-    workerPool.send(0, {foo: 'bar'}, onStart, onEnd);
+    const onCustomMessage = () => {};
+
+    workerPool.send(0, request, onStart, onEnd, onCustomMessage);
 
     expect(ChildProcessWorker).toHaveBeenCalledWith({
       forkOptions: {},
@@ -123,11 +129,12 @@ describe('WorkerPool', () => {
       workerPath: '/path',
     });
     expect(NodeThreadWorker).not.toHaveBeenCalled();
+    // @ts-expect-error: Testing internal method
     expect(workerPool._workers[0].send).toHaveBeenCalledWith(
-      {foo: 'bar'},
+      request,
       onStart,
       onEnd,
-      undefined,
+      onCustomMessage,
     );
   });
 });