@servicetitan/notifications 28.5.0 → 29.0.0

package/src/stores/__mocks__/mock-notifications-channel.ts

@@ -0,0 +1,31 @@
+type EventCallback = (data: any, context: any) => void;
+
+export class MockNotificationsChannel {
+    private readonly bindings: Map<string, EventCallback>;
+
+    constructor() {
+        this.bindings = new Map();
+        Object.assign(this, { bind: this.bindEvent });
+    }
+
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    get global_emitter() {
+        return this;
+    }
+
+    unbind(event: string, fn: EventCallback, _context?: any) {
+        if (this.bindings.get(event) === fn) {
+            this.bindings.delete(event);
+        }
+        return this;
+    }
+
+    emit(event: string, data: any) {
+        this.bindings.get(event)?.(data, undefined);
+    }
+
+    private readonly bindEvent = (event: string, fn: EventCallback, _context?: any) => {
+        this.bindings.set(event, fn);
+        return this;
+    };
+}

package/src/stores/__tests__/notifications.store.test.ts

@@ -0,0 +1,458 @@
+import { toast } from '@servicetitan/anvil2';
+import { MouseEventHandler } from 'react';
+
+import {
+    Notification,
+    NotificationProcessStatus,
+    NotificationsApi,
+} from '../../api/notifications.api';
+import { DefaultNotificationOptions, FunctionAction, LinkAction, Status } from '../../common';
+import { MockNotificationsChannel } from '../__mocks__/mock-notifications-channel';
+
+import { NotificationsStore } from '../notifications.store';
+
+jest.mock('@servicetitan/anvil2', () => ({
+    toast: {
+        info: jest.fn(makeId),
+        success: jest.fn(),
+        warning: jest.fn(),
+        danger: jest.fn(),
+        update: jest.fn(),
+        dismiss: jest.fn(),
+    },
+}));
+
+class MockNotificationsApi implements NotificationsApi {
+    getNotifications = jest.fn().mockResolvedValue({ data: [] });
+    getNotification = jest.fn();
+    changeIsReadProperty = jest.fn();
+}
+
+function makeId() {
+    return Math.round(1e6 * Math.random()).toString(36);
+}
+
+function getServerStatusName(status: NotificationProcessStatus) {
+    return {
+        [NotificationProcessStatus.Info]: 'Info',
+        [NotificationProcessStatus.InProgress]: 'InProgress',
+        [NotificationProcessStatus.Failure]: 'Failure',
+        [NotificationProcessStatus.Success]: 'Success',
+    }[status];
+}
+
+describe(NotificationsStore.name, () => {
+    let store: NotificationsStore | undefined;
+
+    beforeEach(() => {
+        store = undefined;
+        jest.clearAllMocks();
+        jest.useFakeTimers();
+    });
+
+    afterEach(() => {
+        store?.dispose();
+        jest.useRealTimers();
+    });
+
+    describe('when notification is added', () => {
+        let options: DefaultNotificationOptions;
+        let preventDuplicates: boolean | undefined;
+
+        beforeEach(() => {
+            options = { title: 'Foo', message: 'bar', duration: 0, progress: 0 };
+            preventDuplicates = undefined;
+        });
+
+        const subject = () => {
+            if (!store) {
+                store = new NotificationsStore();
+                store.initialize(0);
+            }
+            store.add(options, preventDuplicates);
+        };
+
+        function itAddsToast({ method = 'info' }: { method?: keyof typeof toast } = {}) {
+            test(`adds ${method} toast`, () => {
+                subject();
+
+                const { status, ...toastOptions } = options;
+                expect(toast[method]).toHaveBeenCalledWith(expect.objectContaining(toastOptions));
+            });
+        }
+
+        itAddsToast();
+
+        describe('when preventDuplicates is true', () => {
+            beforeEach(() => (preventDuplicates = true));
+
+            describe('with existing notification', () => {
+                beforeEach(() => {
+                    subject();
+                    jest.clearAllMocks();
+                });
+
+                test('ignores duplicate notification', () => {
+                    subject();
+
+                    expect(toast.info).not.toHaveBeenCalled();
+                });
+
+                describe('with different notification', () => {
+                    beforeEach(() => (options.title = `!${options.title}`));
+
+                    itAddsToast();
+                });
+            });
+        });
+
+        interface TestCase {
+            status: Status;
+            method: keyof typeof toast;
+        }
+
+        describe.each([
+            { status: Status.Success, method: 'success' },
+            { status: Status.Warning, method: 'warning' },
+            { status: Status.Error, method: 'danger' },
+        ] as TestCase[])('when status is "$status"', ({ method, status }) => {
+            beforeEach(() => (options.status = status));
+
+            itAddsToast({ method });
+        });
+
+        describe('when notification has action', () => {
+            let navigate: jest.Func | undefined;
+
+            beforeEach(() => {
+                options.action = { label: 'foo', link: 'bar' };
+                navigate = jest.fn();
+            });
+
+            test('sets duration to false', () => {
+                subject();
+
+                expect(toast.info).toHaveBeenCalledWith(
+                    expect.objectContaining({ duration: false })
+                );
+            });
+
+            describe('when action is clicked', () => {
+                const setup = () => {
+                    subject();
+                    store!.navigate = navigate as any;
+                    jest.mocked(toast.info).mock.calls[0][0].actions?.primary.onClick?.({} as any);
+                };
+
+                test('dismisses toast', () => {
+                    setup();
+
+                    expect(toast.dismiss).toHaveBeenCalled();
+                });
+
+                test('navigates to link', () => {
+                    setup();
+
+                    expect(navigate).toHaveBeenCalledWith((options.action as LinkAction).link);
+                });
+
+                describe('when "navigate" is not defined', () => {
+                    beforeEach(() => (navigate = undefined));
+
+                    test('does nothing', () => {
+                        expect(() => setup()).not.toThrow();
+                    });
+                });
+
+                describe('when link is external', () => {
+                    beforeEach(() => ((options.action as LinkAction).external = true));
+
+                    test('opens link in new window', () => {
+                        const openSpy = jest.spyOn(window, 'open').mockImplementation(jest.fn());
+
+                        setup();
+
+                        expect(openSpy).toHaveBeenCalledWith((options.action as LinkAction).link);
+                    });
+                });
+
+                describe('when action is callback', () => {
+                    beforeEach(() => {
+                        delete (options.action as any).link;
+                        (options.action as FunctionAction).onClick = jest.fn();
+                    });
+
+                    test('invokes callback', () => {
+                        setup();
+
+                        expect((options.action as FunctionAction).onClick).toHaveBeenCalled();
+                    });
+                });
+            });
+        });
+    });
+
+    describe('when notification is published', () => {
+        const userId = 42;
+        const api = new MockNotificationsApi();
+        const publisher = new MockNotificationsChannel();
+        const options: DefaultNotificationOptions = { title: 'Foo' };
+        let notification: Notification;
+
+        beforeEach(() => {
+            notification = {
+                id: 1,
+                userId,
+                type: 'ServerNotification',
+                status: NotificationProcessStatus.Info,
+                isRead: false,
+                createdOn: new Date(),
+                modifiedOn: new Date(),
+                version: 1,
+                payload: JSON.stringify(options),
+            };
+        });
+
+        afterEach(() => store?.dispose());
+
+        const subject = () => {
+            if (!store) {
+                store = new NotificationsStore(api, () => publisher as any);
+                store.initialize(userId);
+            }
+
+            publisher.emit('NotificationEvent', notification);
+        };
+
+        function itAddsToast(method: keyof typeof toast = 'info') {
+            test(`adds ${method} toast`, () => {
+                subject();
+
+                expect(toast[method]).toHaveBeenCalledWith(expect.objectContaining(options));
+            });
+        }
+
+        itAddsToast();
+
+        interface TestCase {
+            status: NotificationProcessStatus;
+            method: keyof typeof toast;
+        }
+
+        describe.each([
+            { status: NotificationProcessStatus.Success, method: 'success' },
+            { status: NotificationProcessStatus.Failure, method: 'danger' },
+            { status: NotificationProcessStatus.InProgress, method: 'info' },
+        ] as TestCase[])('when status is "$status"', ({ method, status }) => {
+            beforeEach(() => (notification.status = status));
+
+            itAddsToast(method);
+        });
+
+        describe('when notification is for different user', () => {
+            beforeEach(() => ++notification.userId);
+
+            test('ignores notification', () => {
+                subject();
+
+                expect(toast.info).not.toHaveBeenCalled();
+            });
+        });
+
+        describe('when notification is closed', () => {
+            const setup = () => {
+                subject();
+                jest.mocked(toast.info).mock.calls[0][0].onClose?.({} as any);
+            };
+
+            test('notifies api', () => {
+                setup();
+
+                expect(api.changeIsReadProperty).toHaveBeenCalledWith(
+                    notification.id,
+                    true,
+                    notification.version
+                );
+            });
+        });
+
+        describe('when notification has interceptor', () => {
+            const newOptions = { title: `!${options.title}` };
+            const interceptor = jest.fn();
+
+            beforeEach(() => {
+                notification.type = makeId();
+                interceptor.mockImplementation(original => ({ ...original, payload: newOptions }));
+                NotificationsStore.intercept(notification.type, interceptor);
+            });
+
+            test('adds toast with interceptor return value', () => {
+                subject();
+
+                expect(toast.info).toHaveBeenCalledWith(expect.objectContaining(newOptions));
+            });
+
+            describe('dismiss callback', () => {
+                let dismissCallback: Function;
+                let onClose: MouseEventHandler<any>;
+                let toastId: string;
+
+                beforeEach(() => {
+                    subject();
+
+                    dismissCallback = interceptor.mock.calls[0][1];
+                    onClose = jest.mocked(toast.info).mock.calls[0][0].onClose!;
+                    toastId = jest.mocked(toast.info).mock.results[0].value;
+
+                    jest.clearAllMocks();
+                });
+
+                test('dismisses toast', () => {
+                    dismissCallback();
+
+                    expect(toast.dismiss).toHaveBeenCalledWith(toastId);
+                });
+
+                describe('when toast is already closed', () => {
+                    beforeEach(() => onClose({} as any));
+
+                    test('does nothing', () => {
+                        dismissCallback();
+
+                        expect(toast.dismiss).not.toHaveBeenCalled();
+                    });
+                });
+            });
+
+            describe('when interceptor returns undefined', () => {
+                beforeEach(() => interceptor.mockReturnValue(undefined));
+
+                test('ignores notification', () => {
+                    subject();
+
+                    expect(toast.info).not.toHaveBeenCalled();
+                });
+            });
+
+            describe('when interceptor is removed', () => {
+                beforeEach(() => NotificationsStore.intercept(notification.type));
+
+                itAddsToast();
+            });
+        });
+
+        [NotificationProcessStatus.Info, NotificationProcessStatus.InProgress].forEach(status => {
+            const name = getServerStatusName(status);
+
+            describe(`when "${name}" notification already exists`, () => {
+                beforeEach(() => {
+                    notification.status = status;
+                    subject();
+                });
+
+                function itUpdatesToast() {
+                    test('updates toast', () => {
+                        subject();
+
+                        expect(toast.update).toHaveBeenCalledWith(
+                            expect.any(String),
+                            expect.objectContaining(options)
+                        );
+                    });
+                }
+
+                function itIgnoresNotification() {
+                    test('ignores notification', () => {
+                        subject();
+
+                        expect(toast.update).not.toHaveBeenCalled();
+                    });
+                }
+
+                itIgnoresNotification();
+
+                describe('when duplicate is newer', () => {
+                    beforeEach(() => (notification.modifiedOn = new Date(Date.now() + 1)));
+
+                    itUpdatesToast();
+
+                    describe('when duplicate has different status', () => {
+                        beforeEach(() => (notification.status = NotificationProcessStatus.Success));
+
+                        test('replaces toast', () => {
+                            subject();
+
+                            expect(toast.dismiss).toHaveBeenCalled();
+                            expect(toast.success).toHaveBeenCalledWith(
+                                expect.objectContaining(options)
+                            );
+                        });
+
+                        describe('when notification has no payload', () => {
+                            beforeEach(() => delete notification.payload);
+
+                            test('replaces with empty toast', () => {
+                                subject();
+
+                                expect(toast.dismiss).toHaveBeenCalled();
+                                expect(toast.success).toHaveBeenCalledWith(
+                                    expect.objectContaining({ title: undefined })
+                                );
+                            });
+                        });
+
+                        if (status !== NotificationProcessStatus.InProgress) {
+                            describe('when new status is "InProgress"', () => {
+                                beforeEach(() => {
+                                    notification.status = NotificationProcessStatus.InProgress;
+                                });
+
+                                itUpdatesToast();
+                            });
+                        }
+                    });
+
+                    if (status === NotificationProcessStatus.InProgress) {
+                        describe('when existing notification was closed', () => {
+                            beforeEach(() => {
+                                jest.mocked(toast.info).mock.calls[0][0].onClose?.({} as any);
+                            });
+
+                            itIgnoresNotification();
+
+                            describe('when duplicate has different status', () => {
+                                beforeEach(() => {
+                                    notification.status = NotificationProcessStatus.Success;
+                                });
+
+                                itAddsToast();
+                            });
+
+                            describe('when notification was close over a day ago', () => {
+                                const DAY_INTERVAL = 24 * 60 * 60 * 1000;
+
+                                beforeEach(() => {
+                                    jest.clearAllMocks();
+                                    jest.setSystemTime(Date.now() + DAY_INTERVAL + 1);
+                                    jest.advanceTimersByTime(DAY_INTERVAL + 1);
+                                });
+
+                                itAddsToast();
+                            });
+                        });
+                    }
+                });
+            });
+        });
+
+        describe('when api has pending notifications', () => {
+            beforeEach(() => api.getNotifications.mockResolvedValue({ data: [notification] }));
+
+            test('adds toast', () => {
+                subject();
+
+                expect(toast.info).toHaveBeenCalledWith(expect.objectContaining(options));
+            });
+        });
+    });
+});