@servicetitan/web-components 22.15.0 → 22.16.0

package/src/__tests__/event-bus.test.ts

@@ -0,0 +1,146 @@
+import * as mitt from 'mitt';
+import { renderHook } from '@testing-library/react-hooks';
+import { useEventBus, EventBus } from '../event-bus';
+
+jest.mock('mitt', () => jest.fn());
+
+describe(`[web-components] ${EventBus.name}`, () => {
+    let eventBus: EventBus;
+    const type = 'event';
+    const handler = jest.fn();
+    const mittOn = jest.fn();
+    const mittOff = jest.fn();
+    const mittEmit = jest.fn();
+
+    beforeEach(() => {
+        jest.spyOn(mitt, 'default').mockImplementation((): any => ({
+            on: mittOn,
+            off: mittOff,
+            emit: mittEmit,
+        }));
+
+        eventBus = new EventBus();
+    });
+
+    describe("when the 'on' method is called", () => {
+        const subject = () => eventBus.on(type, handler);
+
+        test("calls the private mitt instance's 'on' method", () => {
+            subject();
+            expect(mittOn).toHaveBeenCalledWith(type, handler);
+        });
+    });
+
+    describe("when the 'off' method is called", () => {
+        const subject = () => eventBus.off(type, handler);
+
+        test("calls the private mitt instance's 'off' method", () => {
+            subject();
+            expect(mittOff).toHaveBeenCalledWith(type, handler);
+        });
+    });
+
+    describe("when the 'emit' method is called", () => {
+        const data = { foo: 'bar' };
+        const subject = () => eventBus.emit(type, data);
+
+        test("calls the private mitt instance's 'emit' method", () => {
+            subject();
+            expect(mittEmit).toHaveBeenCalledWith(type, data);
+        });
+    });
+
+    describe("when job's 'on' method is called", () => {
+        const subject = () => eventBus.job.on(type, handler);
+
+        test("calls the private mitt instance's 'on' method", () => {
+            subject();
+            expect(mittOn).toHaveBeenCalledWith(type, handler);
+        });
+    });
+
+    describe("when job's 'off' method is called", () => {
+        const subject = () => eventBus.job.off(type, handler);
+
+        test("calls the private mitt instance's 'off' method", () => {
+            subject();
+            expect(mittOff).toHaveBeenCalledWith(type, handler);
+        });
+    });
+
+    describe("when job's 'emit' method is called", () => {
+        const subject = () => eventBus.job.emit(type);
+
+        describe("when emit's 'emit' resolves", () => {
+            beforeEach(() => {
+                mittEmit.mockImplementation((_: any, obj: any) => {
+                    return obj.resolve();
+                });
+            });
+
+            test('the promise resolves', async () => {
+                await expect(subject()).resolves.toBeUndefined();
+            });
+        });
+
+        describe("when emit's 'emit' rejects", () => {
+            const setup = (reason?: any) =>
+                mittEmit.mockImplementation((_: any, obj: any) => {
+                    return obj.reject(reason);
+                });
+
+            describe('with a string reason', () => {
+                const reason = 'reason';
+
+                beforeEach(() => {
+                    setup(reason);
+                });
+
+                test('the promise rejects with the reason', async () => {
+                    await expect(subject()).rejects.toBe(reason);
+                });
+            });
+
+            describe('with an error', () => {
+                const error = Error('reason');
+
+                beforeEach(() => {
+                    setup(error);
+                });
+
+                test('the promise rejects with the error', async () => {
+                    await expect(subject()).rejects.toBe(error);
+                });
+            });
+
+            describe('with no argument', () => {
+                beforeEach(() => {
+                    setup();
+                });
+
+                test('the promise rejects', async () => {
+                    await expect(subject()).rejects.toBeUndefined();
+                });
+            });
+        });
+    });
+});
+
+describe(`[web-components] ${useEventBus.name}`, () => {
+    function subject() {
+        return renderHook(() => useEventBus());
+    }
+
+    test('provides an event bus instance', () => {
+        expect(subject().result.current).toBeInstanceOf(EventBus);
+    });
+
+    test('when the component using useEventBus is re-rendered, useEventBus provides the same event bus instance', () => {
+        const { result, rerender } = subject();
+
+        rerender();
+
+        const [firstInstance, secondInstance] = result.all;
+        expect(firstInstance).toBe(secondInstance);
+    });
+});

package/src/__tests__/globals.test.ts

@@ -0,0 +1,20 @@
+describe('[web-components] globals', () => {
+    function itExportsGlobal(globalName: string) {
+        test(`exports the global ${globalName}`, () => {
+            jest.isolateModules(() => {
+                const globalValue = 'foo';
+                Object.assign(global, { [globalName]: globalValue });
+                const globalsExport = require('../globals')[globalName];
+                expect(globalsExport).toBe(globalValue);
+            });
+        });
+    }
+
+    describe('EXPOSED_DEPENDENCIES', () => {
+        itExportsGlobal('EXPOSED_DEPENDENCIES');
+    });
+
+    describe('WEB_COMPONENT_NAME', () => {
+        itExportsGlobal('WEB_COMPONENT_NAME');
+    });
+});

package/src/__tests__/history-manager.test.ts

@@ -0,0 +1,111 @@
+import { createMemoryHistory, MemoryHistory } from 'history';
+import { HistoryManager } from '../history-manager';
+
+describe(`[web-components] ${HistoryManager.name}`, () => {
+    let historyManager: HistoryManager;
+    let history: MemoryHistory;
+
+    const url = '/foo';
+
+    beforeEach(() => {
+        jest.useFakeTimers();
+        history = createMemoryHistory();
+        historyManager = new HistoryManager();
+        historyManager.register(history);
+    });
+
+    describe('when user navigates to a new location', () => {
+        beforeEach(() => {
+            history.push(url);
+        });
+
+        test('navigates to a new location', () => {
+            expect(history.location.pathname).toEqual(url);
+        });
+    });
+
+    describe('when a second history instance is registered', () => {
+        let history2: MemoryHistory;
+
+        beforeEach(() => {
+            history2 = createMemoryHistory();
+            historyManager.register(history2);
+        });
+
+        describe('when user navigates to a new location', () => {
+            beforeEach(() => {
+                history.push(url);
+            });
+
+            test('navigates to a new location in all registered histories', () => {
+                expect(history.location.pathname).toEqual(url);
+                expect(history2.location.pathname).toEqual(url);
+            });
+        });
+
+        describe('when second history is unregistered', () => {
+            beforeEach(() => {
+                historyManager.unregister(history2);
+            });
+
+            describe('when user navigates to a new location', () => {
+                beforeEach(() => {
+                    history.push(url);
+                });
+
+                test('navigates the first history, but does not navigate second history', () => {
+                    expect(history.location.pathname).toEqual(url);
+                    expect(history2.location.pathname).not.toEqual(url);
+                });
+            });
+        });
+
+        describe('when a redirect is setup to go to a deeper page', () => {
+            const urlRedirect = '/foo/bar';
+
+            beforeEach(() => {
+                history2.listen(location => {
+                    if (location.pathname === url) {
+                        history2.replace(urlRedirect);
+                    }
+                });
+            });
+
+            describe('when user navigates to a new location', () => {
+                beforeEach(() => {
+                    history.push(url);
+                    jest.runOnlyPendingTimers();
+                });
+
+                test('redirects to deeper page', () => {
+                    expect(history.location.pathname).toEqual(urlRedirect);
+                    expect(history2.location.pathname).toEqual(urlRedirect);
+                });
+            });
+        });
+
+        describe('when a redirect is setup to go to a page that is not deeper', () => {
+            const urlRedirect = '/bar';
+
+            beforeEach(() => {
+                history2.listen(location => {
+                    if (location.pathname === url) {
+                        history2.replace(urlRedirect);
+                    }
+                });
+            });
+
+            describe('when user navigates to a new location', () => {
+                beforeEach(() => {
+                    history.push(url);
+                    jest.runOnlyPendingTimers();
+                });
+
+                test('does not redirect', () => {
+                    expect(history.location.pathname).toEqual(url);
+                    expect(history2.location.pathname).toEqual(url);
+                });
+            });
+        });
+    });
+});