@servicetitan/journey 2.0.0 → 3.0.0

package/src/__tests__/integrations/jquery.test.ts

@@ -0,0 +1,539 @@
+/** @jest-environment jsdom */
+import { useJourneyTestRuntime } from '../../__test-utils__/test-runtime';
+import { completeJourney, journeyStep } from '../../core';
+import { moduleRuntime } from '../../core/runtime';
+import { getSharedPolicies } from '../../global';
+import { instrumentJquery } from '../../integrations/jquery/instrument';
+
+const emitMock = jest.fn();
+
+function createJqueryMock() {
+    const prefilters: ((o: any, orig: any, xhr: any) => void)[] = [];
+    const completes: ((event: unknown, xhr: any, settings: any) => void)[] = [];
+
+    const $ = ((_selector: Document) => ({
+        ajaxComplete(handler: (event: unknown, xhr: any, settings: any) => void) {
+            completes.push(handler);
+        },
+    })) as any;
+
+    $.ajaxPrefilter = (handler: (o: any, orig: any, xhr: any) => void) => {
+        prefilters.push(handler);
+    };
+    $.__prefilters = prefilters;
+    $.__completes = completes;
+    return $;
+}
+
+function simulateAjax($: any, url: string, status: number, durationMs = 10) {
+    const xhr = { status };
+    const settings = { url };
+    const start = globalThis.performance.now();
+
+    for (const prefilter of $.__prefilters) {
+        prefilter(settings, settings, xhr);
+    }
+
+    (globalThis.performance.now as jest.Mock).mockReturnValue(start + durationMs);
+
+    for (const complete of $.__completes) {
+        complete({}, xhr, settings);
+    }
+}
+
+describe('[journey] instrumentJquery', () => {
+    useJourneyTestRuntime(emitMock);
+
+    beforeEach(() => {
+        jest.spyOn(globalThis.performance, 'now').mockReturnValue(1_000);
+    });
+
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+
+    test('is idempotent for the same $ instance', () => {
+        const $ = createJqueryMock();
+        instrumentJquery($);
+        instrumentJquery($);
+
+        expect($.__prefilters).toHaveLength(1);
+        expect($.__completes).toHaveLength(1);
+    });
+
+    test('restore then rewire does not stack prefilters', () => {
+        const $ = createJqueryMock();
+        const restore = instrumentJquery($);
+        expect($.__prefilters).toHaveLength(1);
+
+        restore();
+        instrumentJquery($);
+        expect($.__prefilters).toHaveLength(1);
+        expect($.__completes).toHaveLength(1);
+    });
+
+    test.each([undefined, null])('warns and soft-skips when $ is missing (%p)', bad => {
+        const warn = jest.spyOn(console, 'warn').mockImplementation(() => {});
+        const error = jest.spyOn(console, 'error').mockImplementation(() => {});
+
+        expect(() => instrumentJquery(bad)).not.toThrow();
+        expect(warn).toHaveBeenCalledWith(
+            expect.stringContaining('[journey] instrumentJquery: skipped — missing')
+        );
+        expect(error).not.toHaveBeenCalled();
+    });
+
+    test.each([{}, { ajaxPrefilter: 1 }, { ajaxPrefilter: undefined }])(
+        'errors and soft-skips when $ has invalid shape (%p)',
+        bad => {
+            const warn = jest.spyOn(console, 'warn').mockImplementation(() => {});
+            const error = jest.spyOn(console, 'error').mockImplementation(() => {});
+
+            expect(() => instrumentJquery(bad as never)).not.toThrow();
+            expect(error).toHaveBeenCalledWith(
+                expect.stringContaining('[journey] instrumentJquery: skipped — invalid shape (')
+            );
+            expect(error.mock.calls[0]).toHaveLength(1);
+            expect(warn).not.toHaveBeenCalled();
+        }
+    );
+
+    test('does not re-register handlers after a partial wire failure', () => {
+        const $ = createJqueryMock();
+        const error = jest.spyOn(console, 'error').mockImplementation(() => {});
+        const throwing = Object.assign(function throwAjaxComplete() {
+            throw new Error('ajaxComplete boom');
+        }, $) as ReturnType<typeof createJqueryMock>;
+        throwing.ajaxPrefilter = $.ajaxPrefilter;
+        throwing.__prefilters = $.__prefilters;
+        throwing.__completes = $.__completes;
+
+        instrumentJquery(throwing);
+        expect(throwing.__prefilters).toHaveLength(1);
+
+        instrumentJquery(throwing);
+        expect(throwing.__prefilters).toHaveLength(1);
+        expect(error).toHaveBeenCalled();
+    });
+
+    test('restore after a partial wire failure allows a later retry', () => {
+        const $ = createJqueryMock();
+        const error = jest.spyOn(console, 'error').mockImplementation(() => {});
+        let boom = true;
+        const flaky = Object.assign(function maybeThrow(selector: Document) {
+            if (boom) {
+                throw new Error('ajaxComplete boom');
+            }
+            return $(selector);
+        }, $) as ReturnType<typeof createJqueryMock>;
+        flaky.ajaxPrefilter = $.ajaxPrefilter;
+        flaky.__prefilters = $.__prefilters;
+        flaky.__completes = $.__completes;
+
+        const restore = instrumentJquery(flaky);
+        expect(flaky.__prefilters).toHaveLength(1);
+        expect(flaky.__completes).toHaveLength(0);
+        restore();
+
+        boom = false;
+        instrumentJquery(flaky);
+        expect(flaky.__prefilters).toHaveLength(1);
+        expect(flaky.__completes).toHaveLength(1);
+        expect(error).toHaveBeenCalled();
+    });
+
+    test('ignores ajax outside an active journey step', () => {
+        const $ = createJqueryMock();
+        instrumentJquery($);
+
+        moduleRuntime.startJourney({
+            name: 'jq-idle',
+            team: 'test',
+            group: 'test',
+            service: 'test',
+            timeoutMs: 0,
+            slowRequestMs: 50,
+        });
+
+        simulateAjax($, '/CallScreen/BookJob', 500);
+        completeJourney('jq-idle');
+
+        expect(emitMock).toHaveBeenCalledTimes(1);
+        expect(emitMock.mock.calls[0][0].journey.outcome).toBe('good');
+    });
+
+    test('ignore: true on ajax settings skips a 5xx', async () => {
+        const $ = createJqueryMock();
+        instrumentJquery($);
+
+        moduleRuntime.startJourney({
+            name: 'jq-meta-ignore',
+            team: 'test',
+            group: 'test',
+            service: 'test',
+            timeoutMs: 0,
+            slowRequestMs: 50,
+        });
+
+        await journeyStep('jq-meta-ignore', 'book-job', () => {
+            const xhr = { status: 500 };
+            const settings = { url: '/telemetry', ignore: true };
+            for (const prefilter of $.__prefilters) {
+                prefilter(settings, settings, xhr);
+            }
+            for (const complete of $.__completes) {
+                complete({}, xhr, settings);
+            }
+        });
+        completeJourney('jq-meta-ignore');
+
+        expect(emitMock).toHaveBeenCalledTimes(1);
+        expect(emitMock.mock.calls[0][0].journey.outcome).toBe('good');
+    });
+
+    test('step.stamp({ ignore: true }) skips a 5xx', async () => {
+        const $ = createJqueryMock();
+        instrumentJquery($);
+
+        moduleRuntime.startJourney({
+            name: 'jq-stamp-ignore',
+            team: 'test',
+            group: 'test',
+            service: 'test',
+            timeoutMs: 0,
+            slowRequestMs: 50,
+        });
+
+        await journeyStep('jq-stamp-ignore', 'book-job', step => {
+            const tagged = step.stamp({ ignore: true });
+            const xhr = { status: 500, stamp: tagged };
+            const settings = { url: '/CallScreen/BookJob', stamp: tagged };
+            for (const prefilter of $.__prefilters) {
+                prefilter(settings, settings, xhr);
+            }
+            for (const complete of $.__completes) {
+                complete({}, xhr, settings);
+            }
+        });
+        completeJourney('jq-stamp-ignore');
+
+        expect(emitMock).toHaveBeenCalledTimes(1);
+        expect(emitMock.mock.calls[0][0].journey.outcome).toBe('good');
+    });
+
+    test('stamped stamp is JSON-safe on jqXHR and ajax settings', async () => {
+        const $ = createJqueryMock();
+        instrumentJquery($);
+
+        moduleRuntime.startJourney({
+            name: 'jq-json-safe',
+            team: 'test',
+            group: 'test',
+            service: 'test',
+            timeoutMs: 0,
+            slowRequestMs: 5_000,
+        });
+
+        await journeyStep('jq-json-safe', 'book-job', step => {
+            // Ambient stamp lands on jqXHR — common to serialize for logging.
+            const ambientXhr: {
+                status: number;
+                stamp?: unknown;
+                journeyStart?: number;
+            } = { status: 200 };
+            const ambientSettings = { url: '/CallScreen/BookJob' };
+            for (const prefilter of $.__prefilters) {
+                prefilter(ambientSettings, ambientSettings, ambientXhr);
+            }
+            expect(ambientXhr.stamp).toBeUndefined();
+            expect(JSON.parse(JSON.stringify(ambientXhr)).stamp).toBeUndefined();
+
+            // Explicit step.stamp() spread into ajax settings — stripped after capture.
+            const tagged = step.stamp();
+            const settings = { url: '/CallScreen/BookJob', stamp: tagged };
+            for (const prefilter of $.__prefilters) {
+                prefilter(settings, settings, { status: 200 });
+            }
+            expect(settings.stamp).toBeUndefined();
+        });
+        completeJourney('jq-json-safe');
+    });
+
+    test('marks journey bad on 5xx inside a journey step', async () => {
+        const $ = createJqueryMock();
+        instrumentJquery($);
+
+        moduleRuntime.startJourney({
+            name: 'jq-5xx',
+            team: 'test',
+            group: 'test',
+            service: 'test',
+            timeoutMs: 0,
+            slowRequestMs: 5_000,
+        });
+
+        await journeyStep('jq-5xx', 'book-job', () => {
+            simulateAjax($, '/CallScreen/BookJob', 500, 20);
+        });
+
+        expect(emitMock).toHaveBeenCalledTimes(1);
+        const event = emitMock.mock.calls[0][0].journey;
+        expect(event.outcome).toBe('bad');
+        expect(event.reason).toBe('request-error');
+    });
+
+    test('marks journey bad on slow request inside a journey step', async () => {
+        const $ = createJqueryMock();
+        instrumentJquery($);
+
+        moduleRuntime.startJourney({
+            name: 'jq-slow',
+            team: 'test',
+            group: 'test',
+            service: 'test',
+            timeoutMs: 0,
+            slowRequestMs: 50,
+        });
+
+        await journeyStep('jq-slow', 'book-job', () => {
+            simulateAjax($, '/CallScreen/BookJob', 200, 200);
+        });
+
+        expect(emitMock).toHaveBeenCalledTimes(1);
+        const event = emitMock.mock.calls[0][0].journey;
+        expect(event.outcome).toBe('bad');
+        expect(event.reason).toBe('request-latency');
+    });
+
+    test('treats status 0 as a network/request error', async () => {
+        const $ = createJqueryMock();
+        instrumentJquery($);
+
+        moduleRuntime.startJourney({
+            name: 'jq-network',
+            team: 'test',
+            group: 'test',
+            service: 'test',
+            timeoutMs: 0,
+            slowRequestMs: 5_000,
+        });
+
+        await journeyStep('jq-network', 'book-job', () => {
+            simulateAjax($, '/CallScreen/BookJob', 0, 10);
+        });
+
+        expect(emitMock).toHaveBeenCalledTimes(1);
+        expect(emitMock.mock.calls[0][0].journey.outcome).toBe('bad');
+        expect(emitMock.mock.calls[0][0].journey.reason).toBe('request-error');
+    });
+
+    test('does not mark bad on 4xx (user/validation)', async () => {
+        const $ = createJqueryMock();
+        instrumentJquery($);
+
+        moduleRuntime.startJourney({
+            name: 'jq-4xx',
+            team: 'test',
+            group: 'test',
+            service: 'test',
+            timeoutMs: 0,
+            slowRequestMs: 5_000,
+        });
+
+        await journeyStep('jq-4xx', 'book-job', () => {
+            simulateAjax($, '/CallScreen/BookJob', 400, 10);
+        });
+        completeJourney('jq-4xx');
+
+        expect(emitMock).toHaveBeenCalledTimes(1);
+        expect(emitMock.mock.calls[0][0].journey.outcome).toBe('good');
+    });
+
+    test('marks request-aborted when jqXHR statusText is abort', async () => {
+        getSharedPolicies().httpAbortedRequests = 'bad';
+        const $ = createJqueryMock();
+        instrumentJquery($);
+
+        moduleRuntime.startJourney({
+            name: 'jq-abort',
+            team: 'test',
+            group: 'test',
+            service: 'test',
+            timeoutMs: 0,
+            slowRequestMs: 5_000,
+        });
+
+        await journeyStep('jq-abort', 'book-job', () => {
+            const xhr = { status: 0, statusText: 'abort' };
+            const settings = { url: '/CallScreen/BookJob' };
+            const start = globalThis.performance.now();
+            for (const prefilter of $.__prefilters) {
+                prefilter(settings, settings, xhr);
+            }
+            (globalThis.performance.now as jest.Mock).mockReturnValue(start + 10);
+            for (const complete of $.__completes) {
+                complete({}, xhr, settings);
+            }
+        });
+
+        expect(emitMock).toHaveBeenCalledTimes(1);
+        expect(emitMock.mock.calls[0][0].journey.outcome).toBe('bad');
+        expect(emitMock.mock.calls[0][0].journey.reason).toBe('request-aborted');
+    });
+
+    test('honors an explicit stamp already stamped on the XHR', async () => {
+        const $ = createJqueryMock();
+        instrumentJquery($);
+
+        moduleRuntime.startJourney({
+            name: 'jq-explicit',
+            team: 'test',
+            group: 'test',
+            service: 'test',
+            timeoutMs: 0,
+            slowRequestMs: 5_000,
+        });
+
+        await journeyStep('jq-explicit', 'book-job', step => {
+            const tagged = step.stamp();
+            const xhr: {
+                status: number;
+                stamp: unknown;
+                journeyStart?: number;
+            } = { status: 500, stamp: tagged };
+            const settings = { url: '/CallScreen/BookJob' };
+            const start = globalThis.performance.now();
+            for (const prefilter of $.__prefilters) {
+                prefilter(settings, settings, xhr);
+            }
+            // Prefilter must not clear the explicit step; it should stamp a start time.
+            expect(xhr.stamp).toBeUndefined();
+            expect(xhr.journeyStart).toBeDefined();
+            (globalThis.performance.now as jest.Mock).mockReturnValue(start + 20);
+            for (const complete of $.__completes) {
+                complete({}, xhr, settings);
+            }
+        });
+
+        expect(emitMock).toHaveBeenCalledTimes(1);
+        expect(emitMock.mock.calls[0][0].journey.outcome).toBe('bad');
+        expect(emitMock.mock.calls[0][0].journey.reason).toBe('request-error');
+    });
+
+    test('falls back to performance.now when journeyStart is missing', async () => {
+        const $ = createJqueryMock();
+        instrumentJquery($);
+
+        moduleRuntime.startJourney({
+            name: 'jq-no-start',
+            team: 'test',
+            group: 'test',
+            service: 'test',
+            timeoutMs: 0,
+            slowRequestMs: 5_000,
+        });
+
+        await journeyStep('jq-no-start', 'book-job', step => {
+            const tagged = step.stamp();
+            // Bypass prefilter stamping — only fire ajaxComplete with a step and no start.
+            const xhr = { status: 200, stamp: tagged };
+            for (const complete of $.__completes) {
+                complete({}, xhr, { url: '/ok' });
+            }
+        });
+        completeJourney('jq-no-start');
+
+        expect(emitMock).toHaveBeenCalledTimes(1);
+        expect(emitMock.mock.calls[0][0].journey.outcome).toBe('good');
+    });
+
+    test('honors step.stamp() on ajax settings without deep-merge stack overflow', async () => {
+        const $ = createJqueryMock();
+        instrumentJquery($);
+
+        // Mimic jQuery.ajaxSetup: deep-merge plain objects only (class instances by ref).
+        function isPlainObject(obj: unknown): obj is Record<string, unknown> {
+            return (
+                !!obj && typeof obj === 'object' && Object.getPrototypeOf(obj) === Object.prototype
+            );
+        }
+        function deepExtend(target: Record<string, unknown>, ...sources: unknown[]) {
+            for (const source of sources) {
+                if (!source || typeof source !== 'object') {
+                    continue;
+                }
+                for (const key of Object.keys(source as object)) {
+                    // Block prototype-polluting keys (CodeQL js/prototype-pollution-utility).
+                    if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
+                        continue;
+                    }
+                    const copy = (source as Record<string, unknown>)[key];
+                    if (isPlainObject(copy)) {
+                        const dest = isPlainObject(target[key])
+                            ? (target[key] as Record<string, unknown>)
+                            : {};
+                        target[key] = deepExtend(dest, copy);
+                    } else {
+                        target[key] = copy;
+                    }
+                }
+            }
+            return target;
+        }
+
+        moduleRuntime.startJourney({
+            name: 'jq-settings-tag',
+            team: 'test',
+            group: 'test',
+            service: 'test',
+            timeoutMs: 0,
+            slowRequestMs: 5_000,
+        });
+
+        await journeyStep('jq-settings-tag', 'book-job', step => {
+            const tagged = step.stamp();
+            expect(() => deepExtend({}, { stamp: tagged })).not.toThrow();
+            const settings = deepExtend({ url: '/CallScreen/BookJob' }, { stamp: tagged });
+            const xhr: { status: number; stamp?: unknown; journeyStart?: number } = {
+                status: 500,
+            };
+            const start = globalThis.performance.now();
+            for (const prefilter of $.__prefilters) {
+                prefilter(settings, settings, xhr);
+            }
+            expect(xhr.stamp).toBeUndefined();
+            (globalThis.performance.now as jest.Mock).mockReturnValue(start + 20);
+            for (const complete of $.__completes) {
+                complete({}, xhr, settings);
+            }
+        });
+
+        expect(emitMock).toHaveBeenCalledTimes(1);
+        expect(emitMock.mock.calls[0][0].journey.outcome).toBe('bad');
+        expect(emitMock.mock.calls[0][0].journey.reason).toBe('request-error');
+    });
+
+    test('keys cross-origin ajax urls as host/path', async () => {
+        const $ = createJqueryMock();
+        instrumentJquery($);
+
+        moduleRuntime.startJourney({
+            name: 'jq-cross',
+            team: 'test',
+            group: 'test',
+            service: 'test',
+            timeoutMs: 0,
+            slowRequestMs: 5_000,
+            endpoints: [{ match: 'pdf.vendor.com/render', ignore: true }],
+        });
+
+        await journeyStep('jq-cross', 'book-job', () => {
+            simulateAjax($, 'https://pdf.vendor.com/render', 500, 20);
+        });
+        completeJourney('jq-cross');
+
+        // Ignored endpoint — 5xx must not close the journey as bad.
+        expect(emitMock).toHaveBeenCalledTimes(1);
+        expect(emitMock.mock.calls[0][0].journey.outcome).toBe('good');
+    });
+});

package/src/__tests__/{request-key.test.ts → integrations/request-key.test.ts}

@@ -1,5 +1,5 @@
 /** @jest-environment jsdom */
-import { requestKey } from '../integrations/request-key';
+import { requestKey } from '../../integrations/request-key';
 
 describe('[journey] requestKey', () => {
     // Do not redefine window.location — jsdom's property is non-configurable.