add custom jest matchers

Author: itsmylife

jest-setup.js

@@ -4,3 +4,7 @@ import { TextEncoder, TextDecoder } from 'util';
 
 global.TextEncoder = TextEncoder;
 global.TextDecoder = TextDecoder;
+
+import { matchers } from './src/gcopypaste/public/test/matchers';
+
+expect.extend(matchers);

src/gcopypaste/public/test/matchers/index.ts

@@ -0,0 +1,10 @@
+import { Observable } from 'rxjs';
+
+import { toEmitValues } from './toEmitValues';
+import { toEmitValuesWith } from './toEmitValuesWith';
+import { ObservableMatchers } from './types';
+
+export const matchers: ObservableMatchers<void, Observable<any>> = {
+  toEmitValues,
+  toEmitValuesWith,
+};

src/gcopypaste/public/test/matchers/toEmitValues.test.ts

@@ -0,0 +1,140 @@
+import { interval, Observable, of, throwError } from 'rxjs';
+import { map, mergeMap, take } from 'rxjs/operators';
+
+import { OBSERVABLE_TEST_TIMEOUT_IN_MS } from './types';
+
+describe('toEmitValues matcher', () => {
+  describe('failing tests', () => {
+    describe('passing null in expect', () => {
+      it('should fail', async () => {
+        const observable = null as unknown as Observable<number>;
+
+        const rejects = expect(() => expect(observable).toEmitValues([1, 2, 3])).rejects;
+        await rejects.toThrow();
+      });
+    });
+
+    describe('passing undefined in expect', () => {
+      it('should fail', async () => {
+        const observable = undefined as unknown as Observable<number>;
+
+        const rejects = expect(() => expect(observable).toEmitValues([1, 2, 3])).rejects;
+        await rejects.toThrow();
+      });
+    });
+
+    describe('passing number instead of Observable in expect', () => {
+      it('should fail', async () => {
+        const observable = 1 as unknown as Observable<number>;
+
+        const rejects = expect(() => expect(observable).toEmitValues([1, 2, 3])).rejects;
+        await rejects.toThrow();
+      });
+    });
+
+    describe('wrong number of emitted values', () => {
+      it('should fail', async () => {
+        const observable = interval(10).pipe(take(3));
+
+        const rejects = expect(() => expect(observable).toEmitValues([0, 1])).rejects;
+        await rejects.toThrow();
+      });
+    });
+
+    describe('wrong emitted values', () => {
+      it('should fail', async () => {
+        const observable = interval(10).pipe(take(3));
+
+        const rejects = expect(() => expect(observable).toEmitValues([1, 2, 3])).rejects;
+        await rejects.toThrow();
+      });
+    });
+
+    describe('wrong emitted value types', () => {
+      it('should fail', async () => {
+        const observable = interval(10).pipe(take(3)) as unknown as Observable<string>;
+
+        const rejects = expect(() => expect(observable).toEmitValues(['0', '1', '2'])).rejects;
+        await rejects.toThrow();
+      });
+    });
+
+    describe(`observable that does not complete within ${OBSERVABLE_TEST_TIMEOUT_IN_MS}ms`, () => {
+      it('should fail', async () => {
+        const observable = interval(600);
+
+        const rejects = expect(() => expect(observable).toEmitValues([0])).rejects;
+        await rejects.toThrow();
+      });
+    });
+  });
+
+  describe('passing tests', () => {
+    describe('correct emitted values', () => {
+      it('should pass with correct message', async () => {
+        const observable = interval(10).pipe(take(3));
+        await expect(observable).toEmitValues([0, 1, 2]);
+      });
+    });
+
+    describe('using nested arrays', () => {
+      it('should pass with correct message', async () => {
+        const observable = interval(10).pipe(
+          map((interval) => [{ text: interval.toString(), value: interval }]),
+          take(3)
+        );
+        await expect(observable).toEmitValues([
+          [{ text: '0', value: 0 }],
+          [{ text: '1', value: 1 }],
+          [{ text: '2', value: 2 }],
+        ]);
+      });
+    });
+
+    describe('using nested objects', () => {
+      it('should pass with correct message', async () => {
+        const observable = interval(10).pipe(
+          map((interval) => ({ inner: { text: interval.toString(), value: interval } })),
+          take(3)
+        );
+        await expect(observable).toEmitValues([
+          { inner: { text: '0', value: 0 } },
+          { inner: { text: '1', value: 1 } },
+          { inner: { text: '2', value: 2 } },
+        ]);
+      });
+    });
+
+    describe('correct emitted values with throw', () => {
+      it('should pass with correct message', async () => {
+        const observable = interval(10).pipe(
+          map((interval) => {
+            if (interval > 1) {
+              throw 'an error';
+            }
+
+            return interval;
+          })
+        ) as unknown as Observable<string | number>;
+
+        await expect(observable).toEmitValues([0, 1, 'an error']);
+      });
+    });
+
+    describe('correct emitted values with throwError', () => {
+      it('should pass with correct message', async () => {
+        const observable = interval(10).pipe(
+          mergeMap((interval) => {
+            if (interval === 1) {
+              return throwError('an error');
+            }
+
+            return of(interval);
+          })
+        ) as unknown as Observable<string | number>;
+
+        await expect(observable).toEmitValues([0, 'an error']);
+      });
+    });
+  });
+});

src/gcopypaste/public/test/matchers/toEmitValues.ts

@@ -0,0 +1,90 @@
+import { matcherHint, printExpected, printReceived } from 'jest-matcher-utils';
+import { isEqual } from 'lodash';
+import { Observable, Subscription } from 'rxjs';
+
+import { expectObservable, forceObservableCompletion } from './utils';
+
+function passMessage(received: unknown[], expected: unknown[]) {
+  return `${matcherHint('.not.toEmitValues')}
+
+  Expected observable to emit values:
+    ${printExpected(expected)}
+  Received:
+    ${printReceived(received)}
+    `;
+}
+
+function failMessage(received: unknown[], expected: unknown[]) {
+  return `${matcherHint('.toEmitValues')}
+
+  Expected observable to emit values:
+    ${printExpected(expected)}
+  Received:
+    ${printReceived(received)}
+    `;
+}
+
+function tryExpectations(received: unknown[], expected: unknown[]): jest.CustomMatcherResult {
+  try {
+    if (received.length !== expected.length) {
+      return {
+        pass: false,
+        message: () => failMessage(received, expected),
+      };
+    }
+
+    for (let index = 0; index < received.length; index++) {
+      const left = received[index];
+      const right = expected[index];
+
+      if (!isEqual(left, right)) {
+        return {
+          pass: false,
+          message: () => failMessage(received, expected),
+        };
+      }
+    }
+
+    return {
+      pass: true,
+      message: () => passMessage(received, expected),
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : 'An unknown error occurred';
+    return {
+      pass: false,
+      message: () => message,
+    };
+  }
+}
+
+export function toEmitValues(received: Observable<unknown>, expected: unknown[]): Promise<jest.CustomMatcherResult> {
+  const failsChecks = expectObservable(received);
+  if (failsChecks) {
+    return Promise.resolve(failsChecks);
+  }
+
+  return new Promise((resolve) => {
+    const receivedValues: unknown[] = [];
+    const subscription = new Subscription();
+
+    subscription.add(
+      received.subscribe({
+        next: (value) => {
+          receivedValues.push(value);
+        },
+        error: (err) => {
+          receivedValues.push(err);
+          subscription.unsubscribe();
+          resolve(tryExpectations(receivedValues, expected));
+        },
+        complete: () => {
+          subscription.unsubscribe();
+          resolve(tryExpectations(receivedValues, expected));
+        },
+      })
+    );
+
+    forceObservableCompletion(subscription, resolve);
+  });
+}