chore: add more tests and coverage badge

Author: satya164

.circleci/config.yml

@@ -36,7 +36,12 @@ jobs:
       steps:
         - attach_workspace:
             at: ~/project
-        - run: yarn test
+        - run: |
+            yarn test --coverage
+            cat ./coverage/lcov.info | ./node_modules/.bin/codecov
+        - store_artifacts:
+            path: coverage
+            destination: coverage
 
 workflows:
   version: 2

README.md

@@ -1,6 +1,7 @@
 # web-worker-proxy
 
 [![Build Status][build-badge]][build]
+[![Code Coverage][coverage-badge]][coverage]
 [![MIT License][license-badge]][license]
 [![Version][version-badge]][package]
 [![Bundle size (minified + gzip)][bundle-size-badge]][bundle-size]
@@ -116,7 +117,7 @@ worker.methods.validate(result => {
 });
 ```
 
-To prevent memory leaks, callbacks are cleaned up as soon as they are called. Which means, if your callback is supposed to be called multiple times, it won't work. However, you can persist a callback function for as long as you want with the `persist` helper. Persisting a function keeps around the message event listener used for the operation. You must call `dispose` once the function is no longer needed so that the listener can be cleaned up.
+To prevent memory leaks, callbacks are cleaned up as soon as they are called. Which means, if your callback is supposed to be called multiple times, it won't work. However, you can persist a callback function for as long as you want with the `persist` helper. Persisting a function keeps around the event listeners. You must call `dispose` once the function is no longer needed so that they can be cleaned up.
 
 ```js
 import { persist } from 'web-worker-proxy';
@@ -190,6 +191,8 @@ yarn lint -- --fix
 
 [build-badge]: https://img.shields.io/circleci/project/github/satya164/web-worker-proxy/master.svg?style=flat-square
 [build]: https://circleci.com/gh/satya164/web-worker-proxy
+[coverage-badge]: https://img.shields.io/codecov/c/github/satya164/web-worker-proxy.svg?style=flat-square
+[coverage]: https://codecov.io/github/satya164/web-worker-proxy
 [license-badge]: https://img.shields.io/npm/l/web-worker-proxy.svg?style=flat-square
 [license]: https://opensource.org/licenses/MIT
 [version-badge]: https://img.shields.io/npm/v/web-worker-proxy.svg?style=flat-square

package.json

@@ -30,6 +30,7 @@
     "babel-cli": "^6.26.0",
     "babel-preset-env": "^1.7.0",
     "babel-preset-flow": "^6.23.0",
+    "codecov": "^3.0.4",
     "del-cli": "^1.1.0",
     "eslint": "^4.19.1",
     "eslint-config-satya164": "^1.0.2",

src/__tests__/__utils__/WorkerMock.js

@@ -1,5 +1,6 @@
 /* @flow */
 /* eslint-env node */
+/* istanbul ignore file */
 
 import clone from 'structured-clone';
 

src/__tests__/create.test.js

@@ -0,0 +1,70 @@
+/* @flow */
+
+import create from '../create';
+import { RESULT_SUCCESS, RESULT_ERROR } from '../constants';
+
+it('removes listener after successful operation', async () => {
+  expect.assertions(4);
+
+  let listener;
+
+  const postMessage = (data: any) =>
+    setTimeout(() =>
+      listener({ data: { type: RESULT_SUCCESS, id: data.id, result: 42 } })
+    );
+  const addEventListener = (name, cb) => {
+    expect(name).toBe('message');
+    expect(listener).toBe(undefined);
+    listener = cb;
+  };
+  const removeEventListener = (name, cb) => {
+    expect(name).toBe('message');
+    expect(listener).toBe(cb);
+  };
+
+  const worker = create({
+    postMessage,
+    addEventListener,
+    removeEventListener,
+  });
+
+  await worker.foo.bar;
+});
+
+it('removes listener after error', async () => {
+  expect.assertions(4);
+
+  let listener;
+
+  const postMessage = (data: any) =>
+    setTimeout(() =>
+      listener({
+        data: {
+          type: RESULT_ERROR,
+          id: data.id,
+          error: { name: 'Error', message: '', stack: '' },
+        },
+      })
+    );
+  const addEventListener = (name, cb) => {
+    expect(name).toBe('message');
+    expect(listener).toBe(undefined);
+    listener = cb;
+  };
+  const removeEventListener = (name, cb) => {
+    expect(name).toBe('message');
+    expect(listener).toBe(cb);
+  };
+
+  const worker = create({
+    postMessage,
+    addEventListener,
+    removeEventListener,
+  });
+
+  try {
+    await worker.foo.bar;
+  } catch (e) {
+    // ignore
+  }
+});

src/__tests__/index.test.js

@@ -17,9 +17,15 @@ const worker = create(
         methods: {
           add: (a, b) => a + b,
 
-          timeout: duration =>
-            new Promise(resolve =>
-              setTimeout(() => resolve('Hello there'), duration)
+          timeout: (duration, error) =>
+            new Promise((resolve, reject) =>
+              setTimeout(
+                () =>
+                  error
+                    ? reject(new Error("Can't do this anymore"))
+                    : resolve('Hello there'),
+                duration
+              )
             ),
 
           error() {
@@ -60,9 +66,15 @@ it('gets result from synchronous function', async () => {
 });
 
 it('gets result from async function', async () => {
-  expect.assertions(1);
+  expect.assertions(2);
 
   expect(await worker.methods.timeout(0)).toBe('Hello there');
+
+  try {
+    await worker.methods.timeout(0, true);
+  } catch (e) {
+    expect(e.message).toBe("Can't do this anymore");
+  }
 });
 
 it('catches thrown errors', async () => {

src/__tests__/intercept.test.js

@@ -71,11 +71,43 @@ it('intercepts construction', async () => {
     expect(actions).toEqual([
       { type: 'get', key: 'foo' },
       { type: 'get', key: 'bar' },
-      { type: 'apply', key: 'baz', args: ['yo', 42] },
+      { type: 'construct', key: 'baz', args: ['yo', 42] },
     ]);
 
     return 'hello world';
   });
 
   expect(await new o.foo.bar.baz('yo', 42)).toBe('hello world');
 });
+
+it('returns cached promise when accessed from saved variable', async () => {
+  expect.assertions(1);
+
+  const o = intercept(async () => {
+    // Return an object so we compare references
+    return {};
+  });
+
+  const { baz } = o.foo.bar;
+
+  const a = await baz;
+  const b = await baz;
+
+  expect(a).toBe(b);
+});
+
+it('executes again when accessed directly', async () => {
+  expect.assertions(2);
+
+  let i = 0;
+
+  const o = intercept(async () => {
+    return i++;
+  });
+
+  const a = await o.foo.bar.baz;
+  const b = await o.foo.bar.baz;
+
+  expect(a).toBe(0);
+  expect(b).toBe(1);
+});

src/__tests__/persist.test.js

@@ -0,0 +1,35 @@
+/* @flow */
+
+import persist from '../persist';
+import { MESSAGE_DISPOSED_ERROR } from '../constants';
+
+it('returns an object for persisting the function', () => {
+  const func = jest.fn();
+  const callback = persist(func);
+
+  expect(callback.disposed).toBe(false);
+
+  callback.apply(42);
+
+  expect(func).toHaveBeenCalledWith(42);
+});
+
+it('calls dispose listeners after disposing', () => {
+  const listener = jest.fn();
+  const callback = persist(jest.fn());
+
+  callback.on('dispose', listener);
+  callback.dispose();
+
+  expect(listener).toHaveBeenCalled();
+  expect(callback.disposed).toBe(true);
+});
+
+it('throws error when called disposing', () => {
+  const callback = persist(jest.fn());
+
+  callback.dispose();
+
+  expect(callback.disposed).toBe(true);
+  expect(() => callback.apply()).toThrowError(MESSAGE_DISPOSED_ERROR);
+});