tests: add flareVue tests

Author: Sébastien Henau

packages/vue/tests/flareVue.test.ts

@@ -2,6 +2,7 @@ import { beforeEach, describe, expect, test, vi } from 'vitest';
 import type { ComponentPublicInstance } from 'vue';
 
 import { flareVue } from '../src/flareVue';
+import type { FlareVueContext, FlareVueOptions } from '../src/types';
 
 const mockReport = vi.fn();
 
@@ -239,4 +240,253 @@ describe('flareVue', () => {
             app.config.errorHandler!(new Error('original'), null, 'setup function');
         }).toThrow('report failed');
     });
+
+    test('works without options', () => {
+        const app = createMockApp();
+        (flareVue as Function)(app);
+
+        callHandler(app, new Error('test'), null, 'setup function');
+
+        expect(mockReport).toHaveBeenCalledOnce();
+    });
+
+    test('calls beforeEvaluate before building context and reporting', () => {
+        const callOrder: string[] = [];
+
+        const beforeEvaluate = vi.fn(() => callOrder.push('beforeEvaluate'));
+        mockReport.mockImplementation(() => callOrder.push('report'));
+
+        const app = createMockApp();
+        (flareVue as Function)(app, { beforeEvaluate } satisfies FlareVueOptions);
+
+        callHandler(app, new Error('test'), null, 'setup function');
+
+        expect(beforeEvaluate).toHaveBeenCalledOnce();
+        expect(callOrder).toEqual(['beforeEvaluate', 'report']);
+    });
+
+    test('calls beforeEvaluate with error, instance, and info', () => {
+        const beforeEvaluate = vi.fn();
+
+        const app = createMockApp();
+        (flareVue as Function)(app, { beforeEvaluate } satisfies FlareVueOptions);
+
+        const error = new Error('test');
+        const instance = createMockInstance('MyComponent');
+
+        callHandler(app, error, instance, 'setup function');
+
+        expect(beforeEvaluate.mock.calls[0][0].error).toBe(error);
+        expect(beforeEvaluate.mock.calls[0][0].instance).toBe(instance);
+        expect(beforeEvaluate.mock.calls[0][0].info).toBe('setup function');
+    });
+
+    test('passes the converted error (not raw value) to beforeEvaluate', () => {
+        const beforeEvaluate = vi.fn();
+
+        const app = createMockApp();
+        (flareVue as Function)(app, { beforeEvaluate } satisfies FlareVueOptions);
+
+        callHandler(app, 'string error', null, 'setup function');
+
+        expect(beforeEvaluate.mock.calls[0][0].error).toBeInstanceOf(Error);
+        expect(beforeEvaluate.mock.calls[0][0].error.message).toBe('string error');
+    });
+
+    test('calls beforeSubmit after beforeEvaluate and before reporting', () => {
+        const callOrder: string[] = [];
+
+        const beforeEvaluate = vi.fn(() => callOrder.push('beforeEvaluate'));
+        const beforeSubmit = vi.fn((params: { context: FlareVueContext }) => {
+            callOrder.push('beforeSubmit');
+            return params.context;
+        });
+        mockReport.mockImplementation(() => callOrder.push('report'));
+
+        const app = createMockApp();
+        (flareVue as Function)(app, { beforeEvaluate, beforeSubmit } satisfies FlareVueOptions);
+
+        callHandler(app, new Error('test'), null, 'setup function');
+
+        expect(beforeSubmit).toHaveBeenCalledOnce();
+        expect(callOrder).toEqual(['beforeEvaluate', 'beforeSubmit', 'report']);
+    });
+
+    test('calls beforeSubmit with error, instance, info, and context', () => {
+        const beforeSubmit = vi.fn(
+            (params: { error: Error; instance: unknown; info: string; context: FlareVueContext }) => params.context
+        );
+
+        const app = createMockApp();
+        (flareVue as Function)(app, { beforeSubmit } satisfies FlareVueOptions);
+
+        const error = new Error('test');
+        const instance = createMockInstance('MyComponent');
+
+        callHandler(app, error, instance, 'render function');
+
+        expect(beforeSubmit.mock.calls[0][0].error).toBe(error);
+        expect(beforeSubmit.mock.calls[0][0].instance).toBe(instance);
+        expect(beforeSubmit.mock.calls[0][0].info).toBe('render function');
+        expect(beforeSubmit.mock.calls[0][0].context.vue.componentName).toBe('MyComponent');
+        expect(beforeSubmit.mock.calls[0][0].context.vue.componentHierarchy).toEqual(['MyComponent']);
+    });
+
+    test('beforeSubmit can modify the context before reporting', () => {
+        const customHierarchy = ['Custom', 'Modified'];
+        const beforeSubmit = vi.fn(({ context }: { context: FlareVueContext }) => ({
+            ...context,
+            vue: {
+                ...context.vue,
+                componentHierarchy: customHierarchy,
+            },
+        }));
+
+        const app = createMockApp();
+        (flareVue as Function)(app, { beforeSubmit } satisfies FlareVueOptions);
+
+        callHandler(app, new Error('test'), createMockInstance('MyComponent'), 'setup function');
+
+        const reportedContext = mockReport.mock.calls[0][1];
+        expect(reportedContext.vue.componentHierarchy).toBe(customHierarchy);
+    });
+
+    test('uses original context when beforeSubmit does not return', () => {
+        const beforeSubmit = vi.fn(() => {
+            // user forgot to return context
+        });
+
+        const app = createMockApp();
+        // @ts-expect-error - intentionally testing a user mistake where beforeSubmit does not return
+        (flareVue as Function)(app, { beforeSubmit });
+
+        callHandler(app, new Error('test'), createMockInstance('MyComponent'), 'setup function');
+
+        expect(beforeSubmit).toHaveBeenCalledOnce();
+        const reportedContext = mockReport.mock.calls[0][1];
+        expect(reportedContext.vue.componentName).toBe('MyComponent');
+    });
+
+    test('calls afterSubmit after reporting', () => {
+        const callOrder: string[] = [];
+
+        mockReport.mockImplementation(() => callOrder.push('report'));
+        const afterSubmit = vi.fn(() => {
+            callOrder.push('afterSubmit');
+        });
+
+        const app = createMockApp();
+        (flareVue as Function)(app, { afterSubmit } satisfies FlareVueOptions);
+
+        const error = new Error('test');
+        const instance = createMockInstance('MyComponent');
+
+        callHandler(app, error, instance, 'render function');
+
+        expect(afterSubmit).toHaveBeenCalledOnce();
+        expect(afterSubmit.mock.calls[0][0].error).toBe(error);
+        expect(afterSubmit.mock.calls[0][0].instance).toBe(instance);
+        expect(afterSubmit.mock.calls[0][0].info).toBe('render function');
+        expect(afterSubmit.mock.calls[0][0].context.vue.componentHierarchy).toBeInstanceOf(Array);
+        expect(callOrder).toEqual(['report', 'afterSubmit']);
+    });
+
+    test('beforeSubmit modified context is passed to afterSubmit', () => {
+        const customHierarchy = ['Custom', 'Modified'];
+        const beforeSubmit = vi.fn(({ context }: { context: FlareVueContext }) => ({
+            ...context,
+            vue: {
+                ...context.vue,
+                componentHierarchy: customHierarchy,
+            },
+        }));
+        const afterSubmit = vi.fn();
+
+        const app = createMockApp();
+        (flareVue as Function)(app, { beforeSubmit, afterSubmit } satisfies FlareVueOptions);
+
+        callHandler(app, new Error('test'), createMockInstance('MyComponent'), 'setup function');
+
+        expect(afterSubmit.mock.calls[0][0].context.vue.componentHierarchy).toBe(customHierarchy);
+    });
+
+    test('beforeEvaluate throwing prevents reporting and propagates', () => {
+        const beforeEvaluate = vi.fn(() => {
+            throw new Error('beforeEvaluate error');
+        });
+
+        const app = createMockApp();
+        (flareVue as Function)(app, { beforeEvaluate } satisfies FlareVueOptions);
+
+        expect(() => {
+            app.config.errorHandler!(new Error('test'), null, 'setup function');
+        }).toThrow('beforeEvaluate error');
+
+        expect(beforeEvaluate).toHaveBeenCalledOnce();
+        expect(mockReport).not.toHaveBeenCalled();
+    });
+
+    test('beforeSubmit throwing prevents reporting and propagates', () => {
+        const beforeSubmit = vi.fn(() => {
+            throw new Error('beforeSubmit error');
+        });
+
+        const app = createMockApp();
+        (flareVue as Function)(app, { beforeSubmit } satisfies FlareVueOptions);
+
+        expect(() => {
+            app.config.errorHandler!(new Error('test'), null, 'setup function');
+        }).toThrow('beforeSubmit error');
+
+        expect(beforeSubmit).toHaveBeenCalledOnce();
+        expect(mockReport).not.toHaveBeenCalled();
+    });
+
+    test('afterSubmit throwing propagates after reporting', () => {
+        const afterSubmit = vi.fn(() => {
+            throw new Error('afterSubmit error');
+        });
+
+        const app = createMockApp();
+        (flareVue as Function)(app, { afterSubmit } satisfies FlareVueOptions);
+
+        expect(() => {
+            app.config.errorHandler!(new Error('test'), null, 'setup function');
+        }).toThrow('afterSubmit error');
+
+        expect(afterSubmit).toHaveBeenCalledOnce();
+        expect(mockReport).toHaveBeenCalledOnce();
+    });
+
+    test('callbacks fire for each error when called multiple times', () => {
+        const initialHandler = vi.fn();
+        const beforeEvaluate = vi.fn();
+        const beforeSubmit = vi.fn((params: { context: FlareVueContext }) => params.context);
+        const afterSubmit = vi.fn();
+
+        const app = createMockApp(initialHandler);
+        (flareVue as Function)(app, { beforeEvaluate, beforeSubmit, afterSubmit } satisfies FlareVueOptions);
+
+        app.config.errorHandler!(new Error('first'), null, 'setup function');
+        app.config.errorHandler!(new Error('second'), null, 'render function');
+
+        expect(beforeEvaluate).toHaveBeenCalledTimes(2);
+        expect(beforeSubmit).toHaveBeenCalledTimes(2);
+        expect(afterSubmit).toHaveBeenCalledTimes(2);
+    });
+
+    test('afterSubmit is called before initial error handler', () => {
+        const callOrder: string[] = [];
+
+        const initialHandler = vi.fn(() => callOrder.push('initialHandler'));
+        mockReport.mockImplementation(() => callOrder.push('report'));
+        const afterSubmit = vi.fn(() => callOrder.push('afterSubmit'));
+
+        const app = createMockApp(initialHandler);
+        (flareVue as Function)(app, { afterSubmit } satisfies FlareVueOptions);
+
+        app.config.errorHandler!(new Error('test'), null, 'setup function');
+
+        expect(callOrder).toEqual(['report', 'afterSubmit', 'initialHandler']);
+    });
 });