tests: add router tests

Author: Sébastien Henau

packages/vue/tests/flareVue.test.ts

@@ -14,14 +14,22 @@ vi.mock('@flareapp/js', () => ({
     },
 }));
 
+function createMockRouter(route: Record<string, unknown>) {
+    return { currentRoute: { value: route } };
+}
+
 function createMockApp(options?: {
     errorHandler?: (...args: unknown[]) => void;
     warnHandler?: (...args: unknown[]) => void;
+    router?: ReturnType<typeof createMockRouter>;
 }) {
     return {
         config: {
             errorHandler: options?.errorHandler ?? undefined,
             warnHandler: options?.warnHandler ?? undefined,
+            globalProperties: {
+                $router: options?.router ?? undefined,
+            } as Record<string, unknown>,
         },
     };
 }
@@ -636,3 +644,81 @@ describe('flareVue captureWarnings', () => {
         expect(mockReportMessage.mock.calls[1][0]).toBe('Second warning');
     });
 });
+
+describe('flareVue route context', () => {
+    const mockRoute = {
+        name: 'user-profile',
+        path: '/users/42',
+        fullPath: '/users/42?tab=settings',
+        params: { id: '42' },
+        query: { tab: 'settings' },
+        hash: '',
+        matched: [{ name: 'AppLayout' }, { name: 'UserProfile' }],
+    };
+
+    test('includes route context when Vue Router is present', () => {
+        const app = createMockApp({ router: createMockRouter(mockRoute) });
+        (flareVue as Function)(app);
+
+        callHandler(app, new Error('test'), null, 'setup function');
+
+        const context = mockReport.mock.calls[0][1];
+        expect(context.vue.route).toEqual({
+            name: 'user-profile',
+            path: '/users/42',
+            fullPath: '/users/42?tab=settings',
+            params: { id: '42' },
+            query: { tab: 'settings' },
+            hash: '',
+            matched: ['AppLayout', 'UserProfile'],
+        });
+    });
+
+    test('does not include route context when Vue Router is not present', () => {
+        const app = createMockApp();
+        (flareVue as Function)(app);
+
+        callHandler(app, new Error('test'), null, 'setup function');
+
+        const context = mockReport.mock.calls[0][1];
+        expect(context.vue.route).toBeUndefined();
+    });
+
+    test('includes route context in warning reports when Vue Router is present', () => {
+        const app = createMockApp({ router: createMockRouter(mockRoute) });
+        (flareVue as Function)(app, { captureWarnings: true } satisfies FlareVueOptions);
+
+        app.config.warnHandler!('Invalid prop', null, 'trace');
+
+        const context = mockReportMessage.mock.calls[0][1];
+        expect(context.vue.route).toEqual({
+            name: 'user-profile',
+            path: '/users/42',
+            fullPath: '/users/42?tab=settings',
+            params: { id: '42' },
+            query: { tab: 'settings' },
+            hash: '',
+            matched: ['AppLayout', 'UserProfile'],
+        });
+    });
+
+    test('does not include route context in warning reports when Vue Router is not present', () => {
+        const app = createMockApp();
+        (flareVue as Function)(app, { captureWarnings: true } satisfies FlareVueOptions);
+
+        app.config.warnHandler!('Warning', null, '');
+
+        const context = mockReportMessage.mock.calls[0][1];
+        expect(context.vue.route).toBeUndefined();
+    });
+
+    test('route context is available to beforeSubmit hook', () => {
+        const beforeSubmit = vi.fn(({ context }: { context: FlareVueContext }) => context);
+        const app = createMockApp({ router: createMockRouter(mockRoute) });
+        (flareVue as Function)(app, { beforeSubmit } satisfies FlareVueOptions);
+
+        callHandler(app, new Error('test'), null, 'setup function');
+
+        expect(beforeSubmit.mock.calls[0][0].context.vue.route?.name).toBe('user-profile');
+    });
+});

packages/vue/tests/getRouteContext.test.ts

@@ -0,0 +1,145 @@
+import { describe, expect, test } from 'vitest';
+
+import { getRouteContext } from '../src/getRouteContext';
+
+function createMockRouter(route: Record<string, unknown>) {
+    return { currentRoute: { value: route } };
+}
+
+describe('getRouteContext', () => {
+    test('returns null when router is null', () => {
+        expect(getRouteContext(null)).toBeNull();
+    });
+
+    test('returns null when router is undefined', () => {
+        expect(getRouteContext(undefined)).toBeNull();
+    });
+
+    test('returns null when router is not an object', () => {
+        expect(getRouteContext('string')).toBeNull();
+        expect(getRouteContext(42)).toBeNull();
+    });
+
+    test('returns null when router has no currentRoute', () => {
+        expect(getRouteContext({})).toBeNull();
+    });
+
+    test('returns null when currentRoute has no value', () => {
+        expect(getRouteContext({ currentRoute: {} })).toBeNull();
+    });
+
+    test('returns null when currentRoute.value is null', () => {
+        expect(getRouteContext({ currentRoute: { value: null } })).toBeNull();
+    });
+
+    test('extracts route context from a valid router', () => {
+        const router = createMockRouter({
+            name: 'user-profile',
+            path: '/users/42',
+            fullPath: '/users/42?tab=settings',
+            params: { id: '42' },
+            query: { tab: 'settings' },
+            hash: '',
+            matched: [{ name: 'AppLayout' }, { name: 'UserProfile' }],
+        });
+
+        expect(getRouteContext(router)).toEqual({
+            name: 'user-profile',
+            path: '/users/42',
+            fullPath: '/users/42?tab=settings',
+            params: { id: '42' },
+            query: { tab: 'settings' },
+            hash: '',
+            matched: ['AppLayout', 'UserProfile'],
+        });
+    });
+
+    test('returns null name when route name is not a string or symbol', () => {
+        const router = createMockRouter({
+            name: undefined,
+            path: '/',
+            fullPath: '/',
+            params: {},
+            query: {},
+            hash: '',
+            matched: [],
+        });
+
+        expect(getRouteContext(router)!.name).toBeNull();
+    });
+
+    test('converts symbol route name to string', () => {
+        const sym = Symbol('my-route');
+        const router = createMockRouter({
+            name: sym,
+            path: '/',
+            fullPath: '/',
+            params: {},
+            query: {},
+            hash: '',
+            matched: [],
+        });
+
+        expect(getRouteContext(router)!.name).toBe(sym.toString());
+    });
+
+    test('converts symbol matched record names to string', () => {
+        const sym = Symbol('layout');
+        const router = createMockRouter({
+            name: 'home',
+            path: '/',
+            fullPath: '/',
+            params: {},
+            query: {},
+            hash: '',
+            matched: [{ name: sym }, { name: 'Home' }],
+        });
+
+        expect(getRouteContext(router)!.matched).toEqual([sym.toString(), 'Home']);
+    });
+
+    test('uses "unknown" for matched records without a name', () => {
+        const router = createMockRouter({
+            name: 'home',
+            path: '/',
+            fullPath: '/',
+            params: {},
+            query: {},
+            hash: '',
+            matched: [{ name: undefined }, {}],
+        });
+
+        expect(getRouteContext(router)!.matched).toEqual(['unknown', 'unknown']);
+    });
+
+    test('defaults to empty values when route properties are missing', () => {
+        const router = createMockRouter({});
+
+        expect(getRouteContext(router)).toEqual({
+            name: null,
+            path: '',
+            fullPath: '',
+            params: {},
+            query: {},
+            hash: '',
+            matched: [],
+        });
+    });
+
+    test('handles route with hash and query params', () => {
+        const router = createMockRouter({
+            name: 'docs',
+            path: '/docs',
+            fullPath: '/docs?version=3#api',
+            params: {},
+            query: { version: '3' },
+            hash: '#api',
+            matched: [{ name: 'Docs' }],
+        });
+
+        const result = getRouteContext(router)!;
+        expect(result.hash).toBe('#api');
+        expect(result.query).toEqual({ version: '3' });
+        expect(result.fullPath).toBe('/docs?version=3#api');
+    });
+});