@jpmorganchase/mosaic-core 0.1.0-beta.3

package/src/__tests__/PullDocs.test.ts

@@ -0,0 +1,96 @@
+import PullDocs from '../PullDocs';
+import SourceManager from '../SourceManager';
+import UnionVolume from '../filesystems/UnionVolume';
+import MutableVolume from '../filesystems/MutableVolume';
+
+jest.mock('../SourceManager');
+
+describe('GIVEN PullDocs', () => {
+  test('THEN it should instantiate correctly', () => {
+    expect(new PullDocs({ sources: [], plugins: [] })).toBeDefined();
+  });
+
+  test('THEN it should have an onSourceUpdate method', () => {
+    expect(new PullDocs({ sources: [], plugins: [] })).toHaveProperty('onSourceUpdate');
+  });
+
+  describe('WITH plugins specified', () => {
+    let pullDocs;
+
+    beforeEach(() => {
+      SourceManager.mockReset();
+      pullDocs = new PullDocs({
+        sources: [{ modulePath: 'source', name: 'name' }],
+        plugins: [{ modulePath: 'plugin', filter: /[a-z]$/ }]
+      });
+    });
+
+    test('THEN the SourceManager should be passed the plugins', () => {
+      expect(SourceManager).toHaveBeenCalledWith(
+        [
+          {
+            modulePath: expect.stringMatching(/\/packages\/plugins\/dist\/\$CodeModPlugin.js/),
+            options: {},
+            priority: Infinity
+          },
+          {
+            filter: /[a-z]$/,
+            modulePath: 'plugin'
+          },
+          {
+            modulePath: expect.stringMatching(/\/packages\/plugins\/dist\/\$TagPlugin.js/),
+            options: {}
+          },
+          {
+            modulePath: expect.stringMatching(/\/packages\/plugins\/dist\/\$AliasPlugin.js/),
+            options: {},
+            priority: -1
+          },
+          {
+            modulePath: expect.stringMatching(/\/packages\/plugins\/dist\/\$RefPlugin.js/),
+            options: {},
+            priority: -1
+          }
+        ],
+        [
+          {
+            filter: /\.json$/,
+            modulePath: expect.stringMatching(/\/packages\/serialisers\/dist\/json.js/),
+            options: {}
+          }
+        ],
+        ['.mdx'],
+        [],
+        expect.any(UnionVolume),
+        expect.any(MutableVolume)
+      );
+    });
+
+    describe('WITH sources specified', () => {
+      let pullDocs: PullDocs;
+
+      const source1 = { name: 'source', modulePath: 'source-module' };
+      const source2 = { name: 'source2', modulePath: 'source2-module' };
+
+      beforeEach(() => {
+        pullDocs = new PullDocs({
+          sources: [source1, source2],
+          plugins: []
+        });
+      });
+
+      describe('AND a source changes', () => {
+        test('THEN onSourceUpdate should be called', () => {
+          const onSourceUpdateSpy = jest.fn();
+          pullDocs.onSourceUpdate(onSourceUpdateSpy);
+
+          const onSourceUpdateCallback = (
+            SourceManager.prototype.onSourceUpdate as jest.MockedFunction<any>
+          ).mock.calls[0][0];
+          onSourceUpdateCallback();
+          expect(onSourceUpdateSpy).toHaveBeenCalled();
+        });
+      });
+    });
+  });
+});

package/src/__tests__/Source.test.ts

@@ -0,0 +1,341 @@
+import EventEmitter from 'events';
+
+import WorkerSubscription, { EVENT } from '../WorkerSubscription';
+import Source from '../Source';
+
+jest.mock('../WorkerSubscription');
+jest.mock('plugin', () => ({}), { virtual: true });
+
+const utf8Encoder = new TextEncoder();
+
+describe('GIVEN Source', () => {
+  test('THEN it should instantiate correctly', () => {
+    expect(
+      new Source({
+        modulePath: 'plugin',
+        namespace: 'test-namespace'
+      })
+    ).toBeDefined();
+  });
+
+  test('THEN sources should get a unique id', () => {
+    expect(
+      typeof new Source({
+        modulePath: 'plugin',
+        namespace: 'test-namespace'
+      }).id
+    ).toEqual('symbol');
+    expect(
+      new Source({
+        modulePath: 'plugin',
+        namespace: 'test-namespace'
+      }).id
+    ).not.toBe(
+      new Source({
+        modulePath: 'plugin',
+        namespace: 'test-namespace'
+      }).id
+    );
+  });
+
+  test('THEN it should have a use method', () => {
+    expect(
+      new Source({
+        modulePath: 'plugin',
+        namespace: 'test-namespace'
+      })
+    ).toHaveProperty('use');
+  });
+
+  test('THEN it should have an onStart method', () => {
+    expect(
+      new Source({
+        modulePath: 'plugin',
+        namespace: 'test-namespace'
+      })
+    ).toHaveProperty('onStart');
+  });
+
+  test('THEN it should have a start method', () => {
+    expect(
+      new Source({
+        modulePath: 'plugin',
+        namespace: 'test-namespace'
+      })
+    ).toHaveProperty('start');
+  });
+
+  test('THEN it should have a stop method', () => {
+    expect(
+      new Source({
+        modulePath: 'plugin',
+        namespace: 'test-namespace'
+      })
+    ).toHaveProperty('stop');
+  });
+
+  test('THEN it should have a onUpdate method', () => {
+    expect(
+      new Source({
+        modulePath: 'plugin',
+        namespace: 'test-namespace'
+      })
+    ).toHaveProperty('onUpdate');
+  });
+
+  test('THEN it should have a onError method', () => {
+    expect(
+      new Source({
+        modulePath: 'plugin',
+        namespace: 'test-namespace'
+      })
+    ).toHaveProperty('onError');
+  });
+
+  describe('WHEN calling `use`', () => {
+    let source: Source;
+
+    beforeEach(async () => {
+      source = new Source({
+        modulePath: 'plugin',
+        namespace: 'test-namespace'
+      });
+
+      source.use([{ modulePath: 'plugin', filter: /$/, options: { plugin: true } }]);
+      await source.start();
+    });
+
+    test('THEN the plugins should be passed to the worker', async () => {
+      expect(WorkerSubscription).toHaveBeenCalledWith({
+        ignorePages: undefined,
+        plugins: [{ modulePath: 'plugin', options: { plugin: true }, filter: /$/ }],
+        modulePath: 'plugin',
+        name: expect.stringMatching(/#5e543256/),
+        namespace: 'test-namespace',
+        options: undefined,
+        pageExtensions: undefined,
+        serialisers: []
+      });
+    });
+  });
+
+  describe('WHEN calling `start`', () => {
+    let source: Source;
+    beforeEach(() => {
+      source = new Source(
+        {
+          modulePath: 'plugin',
+          namespace: 'test-namespace'
+        },
+        { primary: true }
+      );
+      source.use([]);
+      (WorkerSubscription as jest.MockedFunction<any>).mockClear();
+    });
+
+    test('THEN the child worker should be created', async () => {
+      await source.start();
+      expect(WorkerSubscription).toHaveBeenCalledWith({
+        ignorePages: undefined,
+        modulePath: 'plugin',
+        namespace: 'test-namespace',
+        name: expect.stringMatching(/#c7b08e60/),
+        options: { primary: true },
+        pageExtensions: undefined,
+        plugins: [],
+        serialisers: []
+      });
+    });
+  });
+
+  describe('WHEN calling `stop`', () => {
+    let source;
+    let workerSubscriptionSingletonMock;
+
+    afterEach(() => {
+      (WorkerSubscription as jest.MockedFunction<any>).mockRestore();
+    });
+    beforeEach(async () => {
+      workerSubscriptionSingletonMock = {
+        stop: jest.fn(),
+        closed: false,
+        on() {},
+        once() {}
+      };
+      (WorkerSubscription as jest.MockedFunction<any>).mockImplementation(
+        () => workerSubscriptionSingletonMock
+      );
+      source = new Source({
+        modulePath: 'plugin',
+        namespace: 'test-namespace'
+      });
+      await source.start();
+    });
+    test('THEN the worker should throw if the source has not started', () => {
+      source.stop();
+      expect(workerSubscriptionSingletonMock.stop).toHaveBeenCalled();
+      workerSubscriptionSingletonMock.closed = true;
+      expect(() => source.stop()).toThrow(new Error('Cannot stop source that has not started'));
+      expect(workerSubscriptionSingletonMock.stop).toHaveBeenCalledTimes(1);
+    });
+    test('THEN the worker should be closed', () => {
+      source.stop();
+      expect(workerSubscriptionSingletonMock.stop).toHaveBeenCalled();
+    });
+  });
+
+  describe('WHEN events fire', () => {
+    const workerHandlers: {
+      exit: (code: number) => void;
+      start: () => void;
+      message: (data) => void;
+      error: (error: Error) => void;
+    } = {
+      exit: null,
+      start: null,
+      message: null,
+      error: null
+    };
+    let source;
+
+    afterEach(() => {
+      (WorkerSubscription.prototype.on as jest.MockedFunction<any>).mockRestore();
+      (WorkerSubscription.prototype.once as jest.MockedFunction<any>).mockRestore();
+    });
+    beforeEach(async () => {
+      const eventMap = {
+        [EVENT.UPDATE]: 'message',
+        [EVENT.EXIT]: 'exit',
+        [EVENT.ERROR]: 'error',
+        [EVENT.START]: 'start'
+      };
+      jest
+        .spyOn(WorkerSubscription.prototype, 'on')
+        .mockImplementation(function on(event: EVENT, handler) {
+          workerHandlers[eventMap[event]] = handler;
+          return this as EventEmitter;
+        } as any);
+      jest
+        .spyOn(WorkerSubscription.prototype, 'once')
+        .mockImplementation(function on(event: EVENT, handler) {
+          workerHandlers[eventMap[event]] = handler;
+          return this as EventEmitter;
+        } as any);
+
+      source = new Source({
+        modulePath: 'plugin',
+        namespace: 'test-namespace'
+      });
+      source.filesystem.reset = jest.fn();
+
+      await source.start();
+    });
+
+    describe('AND exceptions occur', () => {
+      test('THEN the worker should clear the filesystem on exit', () => {
+        workerHandlers.exit(1);
+        expect(source.filesystem).toEqual(null);
+      });
+      test('THEN the worker should remove listeners on exit', () => {
+        jest.spyOn(EventEmitter.prototype, 'removeAllListeners');
+        workerHandlers.exit(1);
+        expect(EventEmitter.prototype.removeAllListeners).toHaveBeenCalled();
+      });
+      test('THEN start handler should only fire once', () => {
+        const startSpy = jest.fn();
+        source.onStart(startSpy);
+        workerHandlers.start();
+        workerHandlers.start();
+        expect(startSpy).toHaveBeenCalledTimes(1);
+      });
+      test('THEN exit handler should only fire once', () => {
+        const exitSpy = jest.fn();
+        source.onExit(exitSpy);
+        workerHandlers.exit(0);
+        workerHandlers.exit(0);
+        expect(exitSpy).toHaveBeenCalledTimes(1);
+      });
+      test('THEN error handler should only fire once', () => {
+        const errorSpy = jest.fn();
+        source.onError(errorSpy);
+        workerHandlers.error(new Error('an exception that should only trigger an event once'));
+        workerHandlers.error(new Error('an exception that should only trigger an event once'));
+        expect(errorSpy).toHaveBeenCalledTimes(1);
+      });
+    });
+
+    describe('AND event handlers are attached', () => {
+      test('THEN the update handler should return a cleanup function', async () => {
+        const updateSpy = jest.fn();
+        const cleanup = source.onUpdate(updateSpy);
+        cleanup();
+        workerHandlers.message({ data: utf8Encoder.encode("{ key : 'test' }"), type: 'message' });
+        await new Promise(resolve => setTimeout(resolve));
+        expect(updateSpy).not.toHaveBeenCalled();
+      });
+      test('THEN the error handler should return a cleanup function', async () => {
+        const errorSpy = jest.fn();
+        const cleanup = source.onError(errorSpy);
+        cleanup();
+        workerHandlers.error(new Error('something broke'));
+        await new Promise(resolve => setTimeout(resolve));
+        expect(errorSpy).not.toHaveBeenCalled();
+      });
+      test('THEN the update handler should be fired on a message', async () => {
+        const updateSpy = jest.fn();
+        source.onUpdate(updateSpy);
+        workerHandlers.message({
+          data: { content: ['test'], meta: {}, data: { testValue: 'someValue' } },
+          type: 'message'
+        });
+        await new Promise(resolve => setTimeout(resolve));
+        expect(updateSpy).toHaveBeenCalledWith({
+          data: { testValue: 'someValue' },
+          pages: undefined,
+          symlinks: undefined
+        });
+      });
+
+      test('THEN the exit handler should unsubscribe all other handlers', async () => {
+        const exitSpy = jest.fn();
+        const errorSpy = jest.fn();
+        const updateSpy = jest.fn();
+        const startSpy = jest.fn();
+        source.onError(errorSpy);
+        source.onExit(exitSpy);
+        source.onStart(startSpy);
+        source.onUpdate(updateSpy);
+        workerHandlers.exit(0);
+        workerHandlers.error(new Error('i should never be handled'));
+        workerHandlers.message('i should be ignored');
+        workerHandlers.start();
+        expect(exitSpy).toHaveBeenCalledTimes(1);
+        expect(errorSpy).not.toHaveBeenCalled();
+        expect(startSpy).not.toHaveBeenCalled();
+        expect(updateSpy).not.toHaveBeenCalled();
+      });
+
+      test('THEN the start handler should be fired when a worker received a start event', () => {
+        const startSpy = jest.fn();
+        source.onStart(startSpy);
+        workerHandlers.start();
+        expect(startSpy).toHaveBeenCalledTimes(1);
+      });
+
+      test('THEN the exit handler should be fired when the exit event emits', () => {
+        const exitSpy = jest.fn();
+        source.onExit(exitSpy);
+        workerHandlers.exit(1);
+        expect(exitSpy).toHaveBeenCalledTimes(1);
+      });
+
+      test('THEN the error handler should be fired on an error', () => {
+        const error = new Error('something broke');
+        const errorSpy = jest.fn();
+        source.onError(errorSpy);
+        workerHandlers.error(error);
+        expect(errorSpy).toHaveBeenCalledWith(error);
+      });
+    });
+  });
+});

package/src/__tests__/SourceManager.test.ts

@@ -0,0 +1,255 @@
+import debounce from 'lodash/debounce';
+
+import SourceManager from '../SourceManager';
+import Source from '../Source';
+
+jest.mock('../Source');
+jest.mock('lodash/debounce');
+// jest.mock('../worker/helpers/plugins', () => async (plugins, _fs) => {
+//   return async (_, input) => input;
+// });
+
+function scheduleOnUpdateCallback(message) {
+  setTimeout(() => {
+    const onUpdateCallback = getLastUpdateCallback();
+    onUpdateCallback(message);
+  });
+}
+function scheduleOnStartCallback() {
+  setTimeout(() => {
+    const onStartCallback = getOnStartCallback();
+    onStartCallback();
+  });
+}
+
+function getOnStartCallback() {
+  const onStartCallbackCalls = (Source.prototype.onStart as jest.MockedFunction<any>).mock.calls;
+  return onStartCallbackCalls[onStartCallbackCalls.length - 1][0];
+}
+
+function getLastUpdateCallback() {
+  const onUpdateCallbackCalls = (Source.prototype.onUpdate as jest.MockedFunction<any>).mock.calls;
+  return onUpdateCallbackCalls[onUpdateCallbackCalls.length - 1][0];
+}
+
+describe('GIVEN SourceManager', () => {
+  beforeEach(() => {
+    (debounce as jest.MockedFunction<any>).mockImplementation(
+      callback =>
+        (...args) =>
+          setTimeout(() => callback(...args))
+    );
+  });
+  test('THEN it should instantiate correctly', () => {
+    expect(new SourceManager([])).toBeDefined();
+  });
+
+  test('THEN it should have an addSource method', () => {
+    expect(new SourceManager([])).toHaveProperty('addSource');
+  });
+
+  test('THEN it should have an getSource method', () => {
+    expect(new SourceManager([])).toHaveProperty('getSource');
+  });
+
+  test('THEN it should have an destroyAll method', () => {
+    expect(new SourceManager([])).toHaveProperty('destroyAll');
+  });
+
+  describe('WHEN destroying a source', () => {
+    let sourceManager: SourceManager;
+
+    beforeEach(() => {
+      jest.spyOn(Source.prototype, 'onExit').mockReturnValue(jest.fn());
+      jest.spyOn(Source.prototype, 'onError').mockReturnValue(jest.fn());
+      jest.spyOn(Source.prototype, 'onUpdate').mockReturnValue(jest.fn());
+      jest.spyOn(Source.prototype, 'onStart').mockReturnValue(jest.fn());
+      jest.spyOn(Source.prototype, 'stop').mockReturnValue(jest.fn());
+
+      sourceManager = new SourceManager([]);
+    });
+
+    afterEach(() => {
+      (Source.prototype.stop as jest.MockedFunction<any>).mockReset();
+      (Source.prototype.onStart as jest.MockedFunction<any>).mockReset();
+    });
+
+    test('THEN calling `destroyAll` should stop all sources', async () => {
+      (Source.prototype as jest.MockedFunction<any>).id = '1';
+      scheduleOnStartCallback();
+      await sourceManager.addSource({ modulePath: '1', name: '1' }, {});
+      (Source.prototype as jest.MockedFunction<any>).id = '2';
+      scheduleOnStartCallback();
+      await sourceManager.addSource({ modulePath: '2', name: '2' }, {});
+      (Source.prototype as jest.MockedFunction<any>).id = '3';
+      scheduleOnStartCallback();
+      await sourceManager.addSource({ modulePath: '3', name: '3' }, {});
+      sourceManager.destroyAll();
+      expect(Source.prototype.stop).toHaveBeenCalledTimes(3);
+    });
+  });
+
+  describe('WHEN adding a source with plugins', () => {
+    let sourceManager: SourceManager;
+    beforeEach(async () => {
+      Source.prototype.constructorSpy.mockReset();
+      Source.prototype.use.mockReset();
+      sourceManager = new SourceManager([{ options: { plugins: true } }]);
+      scheduleOnStartCallback();
+      await sourceManager.addSource({ name: 'source', modulePath: 'source-module' }, {});
+    });
+    test('THEN the plugins should be used', () => {
+      expect(Source.prototype.use.mock.calls[0][0]).toEqual([{ options: { plugins: true } }]);
+    });
+    test('THEN the sources should be created for the new sources', async () => {
+      scheduleOnStartCallback();
+      await sourceManager.addSource(
+        { name: 'source2', modulePath: 'source-module2', options: { a: true } },
+        {}
+      );
+      expect(Source.prototype.constructorSpy.mock.calls[0][0]).toEqual({
+        name: 'source',
+        modulePath: 'source-module'
+      });
+      expect(Source.prototype.constructorSpy.mock.calls[1][0]).toEqual({
+        name: 'source2',
+        modulePath: 'source-module2',
+        options: { a: true }
+      });
+    });
+  });
+
+  describe('WHEN adding a source', () => {
+    let sourceManager: SourceManager;
+
+    afterEach(() => {});
+    beforeEach(() => {
+      Source.prototype.constructorSpy.mockReset();
+      sourceManager = new SourceManager([]);
+      jest.spyOn(Source.prototype, 'onExit').mockReturnValue(jest.fn());
+      jest.spyOn(Source.prototype, 'onError').mockReturnValue(jest.fn());
+      jest.spyOn(Source.prototype, 'onUpdate').mockReturnValue(jest.fn());
+      jest.spyOn(Source.prototype, 'onStart').mockReturnValue(jest.fn());
+      jest.spyOn(Source.prototype, 'stop').mockClear();
+    });
+    describe('AND the source changes', () => {
+      describe("AND the source hasn't initialised yet", () => {
+        test('THEN `onSourceUpdate` should not be called and an error should be thrown', async () => {
+          const onSourceUpdateSpy = jest.fn();
+          sourceManager.onSourceUpdate(onSourceUpdateSpy);
+          const sourceCreatorPromise = sourceManager.addSource(
+            { name: 'source', modulePath: 'source-module' },
+            {}
+          );
+          const onUpdateCallbackCalls = (Source.prototype.onUpdate as jest.MockedFunction<any>).mock
+            .calls;
+          const latestOnUpdateCallback = onUpdateCallbackCalls[onUpdateCallbackCalls.length - 1][0];
+          expect(latestOnUpdateCallback).toBeDefined();
+          latestOnUpdateCallback('message');
+
+          expect(() => sourceCreatorPromise).rejects.toThrow('message');
+        });
+      });
+
+      test('THEN `onSourceUpdate` should be called', async () => {
+        const onSourceUpdateSpy = jest.fn();
+        sourceManager.onSourceUpdate(onSourceUpdateSpy);
+
+        scheduleOnUpdateCallback('message');
+
+        await expect(() =>
+          sourceManager.addSource({ name: 'source2', modulePath: 'source2-module' }, {})
+        ).rejects.toThrow(
+          new Error("Source 'source2' received a message before it was initialised.")
+        );
+      });
+
+      test('THEN `onSourceUpdate` should be called with a filesystem', async () => {
+        const onSourceUpdateSpy = jest.fn();
+        sourceManager.onSourceUpdate(onSourceUpdateSpy);
+        scheduleOnStartCallback();
+        await sourceManager.addSource({ name: 'source', modulePath: 'source-module' }, {});
+
+        const latestOnUpdateCallback = getLastUpdateCallback();
+        expect(latestOnUpdateCallback).toBeDefined();
+        latestOnUpdateCallback(['message1', 'message1.2']);
+
+        scheduleOnStartCallback();
+        await sourceManager.addSource({ name: 'source', modulePath: 'source-module' }, {});
+
+        await new Promise(resolve => setTimeout(resolve));
+        expect(onSourceUpdateSpy.mock.calls[0][1].filesystem).toBeDefined();
+      });
+    });
+
+    test('THEN the source should be available via `getSource`', async () => {
+      scheduleOnStartCallback();
+      const source1 = await sourceManager.addSource(
+        { name: 'source', modulePath: 'source-module' },
+        {}
+      );
+      scheduleOnStartCallback();
+      await sourceManager.addSource({ name: 'source2', modulePath: 'source2-module' }, {});
+      expect(sourceManager.getSource(source1.id)).toBeDefined();
+    });
+
+    test('THEN the sources should be created for the new sources', async () => {
+      scheduleOnStartCallback();
+      await sourceManager.addSource(
+        { name: 'source', modulePath: 'source-module', options: { a: true } },
+        {}
+      );
+      scheduleOnStartCallback();
+      await sourceManager.addSource(
+        { name: 'source2', modulePath: 'source2-module', options: { b: true } },
+        {}
+      );
+
+      expect(Source.prototype.constructorSpy.mock.calls[0][0]).toEqual({
+        name: 'source',
+        modulePath: 'source-module',
+        options: { a: true }
+      });
+      expect(Source.prototype.constructorSpy.mock.calls[1][0]).toEqual({
+        name: 'source2',
+        modulePath: 'source2-module',
+        options: { b: true }
+      });
+    });
+
+    describe('AND an error is thrown or an early exit occurs', () => {
+      beforeEach(() => {
+        jest.spyOn(Source.prototype, 'onError').mockImplementation(() => jest.fn());
+      });
+      test('THEN an error should be reported for any early exit, as a rejected promise', async () => {
+        setTimeout(() => {
+          const onExitCallbackCalls = (Source.prototype.onExit as jest.MockedFunction<any>).mock
+            .calls;
+          const latestOnExitCallback = onExitCallbackCalls[onExitCallbackCalls.length - 1][0];
+          latestOnExitCallback();
+        });
+        await expect(() =>
+          sourceManager.addSource({ name: 'source', modulePath: 'source-module' }, {})
+        ).rejects.toThrow(new Error("Source 'source' silently exited before initialising."));
+      });
+      test('THEN the error should be reported in a rejected promise', async () => {
+        setTimeout(() => {
+          const onErrorCallbackCalls = (Source.prototype.onError as jest.MockedFunction<any>).mock
+            .calls;
+          const latestOnErrorCallback = onErrorCallbackCalls[onErrorCallbackCalls.length - 1][0];
+          latestOnErrorCallback(new Error('some error'));
+        });
+        await expect(() =>
+          sourceManager.addSource({ name: 'source', modulePath: 'source-module' }, {})
+        ).rejects.toThrow(new Error('some error'));
+      });
+    });
+
+    test('THEN it should call `start` on the Source', async () => {
+      jest.spyOn(Source.prototype, 'start');
+      scheduleOnStartCallback();
+      await sourceManager.addSource({ name: 'source', modulePath: 'source-module' }, {});
+      expect(Source.prototype.start).toHaveBeenCalled();
+    });
+  });
+});