@servicetitan/journey 2.1.0 → 3.0.0

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

@@ -1,7 +1,8 @@
 /** @jest-environment jsdom */
 import { useJourneyTestRuntime } from '../../__test-utils__/test-runtime';
-import { completeJourney, JourneyStepTag, journeyStep } from '../../core';
+import { completeJourney, journeyStep } from '../../core';
 import { moduleRuntime } from '../../core/runtime';
+import { getSharedPolicies } from '../../global';
 import { instrumentAxios, type AxiosLikeInstance } from '../../integrations/axios';
 
 const emitMock = jest.fn();
@@ -25,7 +26,12 @@ function createAxiosMock(): AxiosLikeInstance & {
             request: {
                 use(onFulfilled) {
                     request.push(onFulfilled);
-                    return 0;
+                    return request.length - 1;
+                },
+                eject(id) {
+                    if (typeof id === 'number') {
+                        request.splice(id, 1);
+                    }
                 },
             },
             response: {
@@ -34,7 +40,13 @@ function createAxiosMock(): AxiosLikeInstance & {
                     if (onRejected) {
                         responseErr.push(onRejected);
                     }
-                    return 0;
+                    return responseOk.length - 1;
+                },
+                eject(id) {
+                    if (typeof id === 'number') {
+                        responseOk.splice(id, 1);
+                        responseErr.splice(id, 1);
+                    }
                 },
             },
         },
@@ -51,7 +63,7 @@ describe('[journey] instrumentAxios', () => {
         group: 'test',
         service: 'test',
         timeoutMs: 0,
-        requestTimeoutMs: 5_000,
+        slowRequestMs: 5_000,
     };
 
     useJourneyTestRuntime(emitMock);
@@ -74,6 +86,71 @@ describe('[journey] instrumentAxios', () => {
         expect(axios.responseErrHandlers).toHaveLength(1);
     });
 
+    test.each([undefined, null])('warns and soft-skips when axios is missing (%p)', bad => {
+        const warn = jest.spyOn(console, 'warn').mockImplementation(() => {});
+        const error = jest.spyOn(console, 'error').mockImplementation(() => {});
+
+        expect(() => instrumentAxios(bad)).not.toThrow();
+        expect(warn).toHaveBeenCalledWith(
+            expect.stringContaining('[journey] instrumentAxios: skipped — missing')
+        );
+        expect(error).not.toHaveBeenCalled();
+    });
+
+    test.each([{}, { interceptors: {} }, { interceptors: { request: {}, response: {} } }])(
+        'errors and soft-skips when axios has invalid shape (%p)',
+        bad => {
+            const warn = jest.spyOn(console, 'warn').mockImplementation(() => {});
+            const error = jest.spyOn(console, 'error').mockImplementation(() => {});
+
+            expect(() => instrumentAxios(bad as never)).not.toThrow();
+            expect(error).toHaveBeenCalledWith(
+                expect.stringContaining('[journey] instrumentAxios: skipped — invalid shape (')
+            );
+            expect(error.mock.calls[0]).toHaveLength(1);
+            expect(warn).not.toHaveBeenCalled();
+        }
+    );
+
+    test('retries instrumentation after a partial wire failure', () => {
+        const axios = createAxiosMock();
+        const error = jest.spyOn(console, 'error').mockImplementation(() => {});
+        axios.interceptors.response.use = () => {
+            throw new Error('response interceptor boom');
+        };
+
+        instrumentAxios(axios);
+        expect(axios.requestHandlers).toHaveLength(0);
+
+        axios.interceptors.response.use = (onFulfilled, onRejected) => {
+            axios.responseOkHandlers.push(onFulfilled);
+            if (onRejected) {
+                axios.responseErrHandlers.push(onRejected);
+            }
+            return axios.responseOkHandlers.length - 1;
+        };
+        instrumentAxios(axios);
+
+        expect(axios.requestHandlers).toHaveLength(1);
+        expect(axios.responseOkHandlers).toHaveLength(1);
+        expect(error).toHaveBeenCalled();
+    });
+
+    test('restore ejects interceptors so a later wire does not stack', () => {
+        const axios = createAxiosMock();
+        const restore = instrumentAxios(axios);
+        expect(axios.requestHandlers).toHaveLength(1);
+        expect(axios.responseOkHandlers).toHaveLength(1);
+
+        restore();
+        expect(axios.requestHandlers).toHaveLength(0);
+        expect(axios.responseOkHandlers).toHaveLength(0);
+
+        instrumentAxios(axios);
+        expect(axios.requestHandlers).toHaveLength(1);
+        expect(axios.responseOkHandlers).toHaveLength(1);
+    });
+
     test('reports a successful response against the ambient step', async () => {
         const axios = createAxiosMock();
         instrumentAxios(axios);
@@ -81,7 +158,7 @@ describe('[journey] instrumentAxios', () => {
         moduleRuntime.startJourney(def);
         await journeyStep(def.name, 'book-job', () => {
             const config = axios.requestHandlers[0]({ url: '/CallScreen/BookJob' });
-            expect(config.journeyStep).toBeInstanceOf(JourneyStepTag);
+            expect(config.stamp).toBeUndefined();
             expect(config.journeyStart).toBe(1_000);
 
             (globalThis.performance.now as jest.Mock).mockReturnValue(1_050);
@@ -94,7 +171,7 @@ describe('[journey] instrumentAxios', () => {
         expect(emitMock.mock.calls[0][0].journey.outcome).toBe('good');
     });
 
-    test('stamped journeyStep is JSON-safe (AxiosError.toJSON includes config)', async () => {
+    test('stamped stamp is JSON-safe (AxiosError.toJSON includes config)', async () => {
         const axios = createAxiosMock();
         instrumentAxios(axios);
 
@@ -102,24 +179,23 @@ describe('[journey] instrumentAxios', () => {
         await journeyStep(def.name, 'book-job', step => {
             // Ambient stamp — AxiosError.toJSON() embeds config by reference.
             const ambient = axios.requestHandlers[0]({ url: '/CallScreen/BookJob' });
-            expect(ambient.journeyStep).toBeInstanceOf(JourneyStepTag);
+            expect(ambient.stamp).toBeUndefined();
             const ambientSerialized = JSON.stringify({
                 message: 'Request failed',
                 name: 'AxiosError',
                 config: ambient,
                 status: 500,
             });
-            expect(JSON.parse(ambientSerialized).config.journeyStep).toBe('[JourneyStepTag]');
+            expect(JSON.parse(ambientSerialized).config.stamp).toBeUndefined();
 
-            // Explicit step.tag() spread into config — same circular risk.
-            const tagged = step.tag() as { journeyStep: unknown };
+            // Explicit step.stamp() stays on config, but serializes safely via toJSON.
+            const tagged = step.stamp();
             const explicit = axios.requestHandlers[0]({
                 url: '/CallScreen/BookJob',
-                journeyStep: tagged.journeyStep,
+                stamp: tagged,
             });
-            expect(explicit.journeyStep).toBe(tagged.journeyStep);
-            expect(explicit.journeyStep).toBeInstanceOf(JourneyStepTag);
-            expect(JSON.parse(JSON.stringify(explicit)).journeyStep).toBe('[JourneyStepTag]');
+            expect(explicit.stamp).toBe(tagged);
+            expect(JSON.parse(JSON.stringify(explicit)).stamp).toBe('[JourneyStepStamp]');
         });
         completeJourney(def.name);
     });
@@ -145,18 +221,18 @@ describe('[journey] instrumentAxios', () => {
         expect(emitMock.mock.calls[0][0].journey.reason).toBe('request-error');
     });
 
-    test('honors an explicit journeyStep from step.tag()', async () => {
+    test('honors an explicit stamp from step.stamp()', async () => {
         const axios = createAxiosMock();
         instrumentAxios(axios);
 
         moduleRuntime.startJourney(def);
         await journeyStep(def.name, 'book-job', async step => {
-            const tagged = step.tag() as { journeyStep: unknown };
+            const tagged = step.stamp();
             const config = axios.requestHandlers[0]({
                 url: '/CallScreen/BookJob',
-                journeyStep: tagged.journeyStep,
+                stamp: tagged,
             });
-            expect(config.journeyStep).toBe(tagged.journeyStep);
+            expect(config.stamp).toBe(tagged);
 
             (globalThis.performance.now as jest.Mock).mockReturnValue(1_020);
             await expect(
@@ -170,6 +246,102 @@ describe('[journey] instrumentAxios', () => {
         expect(emitMock.mock.calls[0][0].journey.reason).toBe('request-error');
     });
 
+    test('step.stamp score can exclude a 5xx from the response body', async () => {
+        const axios = createAxiosMock();
+        instrumentAxios(axios);
+
+        moduleRuntime.startJourney(def);
+        await expect(
+            journeyStep(def.name, 'book-job', async step => {
+                const tagged = step.stamp(ctx => {
+                    const data = (ctx.response as { data?: { code?: string } } | undefined)?.data;
+                    return data?.code === 'USER_DATA' ? 'exclude' : undefined;
+                });
+                const config = axios.requestHandlers[0]({
+                    url: '/CallScreen/BookJob',
+                    stamp: tagged,
+                });
+                (globalThis.performance.now as jest.Mock).mockReturnValue(1_020);
+                await axios.responseErrHandlers[0]({
+                    config,
+                    response: { status: 500, data: { code: 'USER_DATA' } },
+                });
+            })
+        ).rejects.toMatchObject({ response: { status: 500 } });
+
+        expect(emitMock).toHaveBeenCalledTimes(1);
+        expect(emitMock.mock.calls[0][0].journey.outcome).toBe('excluded');
+    });
+
+    test('ambient auto-attribute does not run a stamp score', async () => {
+        const axios = createAxiosMock();
+        instrumentAxios(axios);
+
+        moduleRuntime.startJourney(def);
+        await expect(
+            journeyStep(def.name, 'book-job', async step => {
+                step.stamp(() => 'exclude');
+                const config = axios.requestHandlers[0]({ url: '/CallScreen/BookJob' });
+                (globalThis.performance.now as jest.Mock).mockReturnValue(1_020);
+                await axios.responseErrHandlers[0]({
+                    config,
+                    response: { status: 500, data: { code: 'USER_DATA' } },
+                });
+            })
+        ).rejects.toMatchObject({ response: { status: 500 } });
+
+        expect(emitMock.mock.calls[0][0].journey.outcome).toBe('bad');
+        expect(emitMock.mock.calls[0][0].journey.reason).toBe('request-error');
+    });
+
+    test('step.stamp({ ignore: true }) does not score a 5xx', async () => {
+        const axios = createAxiosMock();
+        instrumentAxios(axios);
+
+        moduleRuntime.startJourney(def);
+        await journeyStep(def.name, 'book-job', async step => {
+            const tagged = step.stamp({ ignore: true });
+            const config = axios.requestHandlers[0]({
+                url: '/CallScreen/BookJob',
+                stamp: tagged,
+            });
+            expect(config.stamp).toBe(tagged);
+            await expect(
+                axios.responseErrHandlers[0]({
+                    config,
+                    response: { status: 500 },
+                })
+            ).rejects.toMatchObject({ response: { status: 500 } });
+        });
+        completeJourney(def.name);
+        expect(emitMock.mock.calls[0][0].journey.outcome).toBe('good');
+    });
+
+    test('ignore: true skips auto-attribute of a 5xx', async () => {
+        const axios = createAxiosMock();
+        instrumentAxios(axios);
+
+        moduleRuntime.startJourney(def);
+        await journeyStep(def.name, 'book-job', async () => {
+            const config = axios.requestHandlers[0]({
+                url: '/telemetry',
+                ignore: true,
+            });
+            expect(config.stamp).toBeUndefined();
+            (globalThis.performance.now as jest.Mock).mockReturnValue(1_020);
+            await expect(
+                axios.responseErrHandlers[0]({
+                    config,
+                    response: { status: 500 },
+                })
+            ).rejects.toMatchObject({ response: { status: 500 } });
+        });
+        completeJourney(def.name);
+
+        expect(emitMock).toHaveBeenCalledTimes(1);
+        expect(emitMock.mock.calls[0][0].journey.outcome).toBe('good');
+    });
+
     test('soft ambient: overlapping steps do not auto-stamp HTTP', async () => {
         const other = { ...def, name: 'axios-journey-other' };
         const axios = createAxiosMock();
@@ -189,7 +361,7 @@ describe('[journey] instrumentAxios', () => {
 
         await journeyStep(other.name, 'book', async () => {
             const config = axios.requestHandlers[0]({ url: '/CallScreen/BookJob' });
-            expect(config.journeyStep).toBeUndefined();
+            expect(config.stamp).toBeUndefined();
 
             (globalThis.performance.now as jest.Mock).mockReturnValue(1_020);
             await expect(
@@ -210,7 +382,7 @@ describe('[journey] instrumentAxios', () => {
         expect(emitMock.mock.calls.every(c => c[0].journey.outcome === 'good')).toBe(true);
     });
 
-    test('soft ambient: step.tag() still attributes during overlap', async () => {
+    test('soft ambient: step.stamp() still attributes during overlap', async () => {
         const other = { ...def, name: 'axios-journey-tagged' };
         const axios = createAxiosMock();
         instrumentAxios(axios);
@@ -229,12 +401,12 @@ describe('[journey] instrumentAxios', () => {
 
         await expect(
             journeyStep(other.name, 'book', async step => {
-                const tagged = step.tag() as { journeyStep: unknown };
+                const tagged = step.stamp();
                 const config = axios.requestHandlers[0]({
                     url: '/CallScreen/BookJob',
-                    journeyStep: tagged.journeyStep,
+                    stamp: tagged,
                 });
-                expect(config.journeyStep).toBe(tagged.journeyStep);
+                expect(config.stamp).toBe(tagged);
 
                 (globalThis.performance.now as jest.Mock).mockReturnValue(1_020);
                 await axios.responseErrHandlers[0]({
@@ -255,13 +427,40 @@ describe('[journey] instrumentAxios', () => {
         completeJourney(def.name);
     });
 
+    test('keeps explicit stamp attribution when a later interceptor clones config', async () => {
+        const axios = createAxiosMock();
+        instrumentAxios(axios);
+
+        moduleRuntime.startJourney(def);
+        await expect(
+            journeyStep(def.name, 'book-job', async step => {
+                const tagged = step.stamp();
+                const config = axios.requestHandlers[0]({
+                    url: '/CallScreen/BookJob',
+                    stamp: tagged,
+                });
+                const clonedConfig = { ...config };
+
+                (globalThis.performance.now as jest.Mock).mockReturnValue(1_020);
+                await axios.responseErrHandlers[0]({
+                    config: clonedConfig,
+                    response: { status: 500 },
+                });
+            })
+        ).rejects.toMatchObject({ response: { status: 500 } });
+
+        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('ignores responses with no journey step on the config', () => {
         const axios = createAxiosMock();
         instrumentAxios(axios);
 
         // Outside a step — request interceptor finds no ambient step.
         const config = axios.requestHandlers[0]({ url: '/orphan' });
-        expect(config.journeyStep).toBeUndefined();
+        expect(config.stamp).toBeUndefined();
         axios.responseOkHandlers[0]({ status: 500, config });
 
         expect(emitMock).not.toHaveBeenCalled();
@@ -281,10 +480,10 @@ describe('[journey] instrumentAxios', () => {
 
         moduleRuntime.startJourney(def);
         await journeyStep(def.name, 'book-job', step => {
-            const tagged = step.tag() as { journeyStep: unknown };
+            const tagged = step.stamp();
             const config = {
                 url: '/CallScreen/BookJob',
-                journeyStep: tagged.journeyStep,
+                stamp: tagged,
             };
             (globalThis.performance.now as jest.Mock).mockReturnValue(1_200);
             axios.responseOkHandlers[0]({ status: 200, config });
@@ -299,7 +498,7 @@ describe('[journey] instrumentAxios', () => {
         const axios = createAxiosMock();
         instrumentAxios(axios);
 
-        moduleRuntime.startJourney({ ...def, requestTimeoutMs: 50 });
+        moduleRuntime.startJourney({ ...def, slowRequestMs: 50 });
         await journeyStep(def.name, 'book-job', () => {
             const config = axios.requestHandlers[0]({ url: '/CallScreen/BookJob' });
             (globalThis.performance.now as jest.Mock).mockReturnValue(1_200);
@@ -332,6 +531,27 @@ describe('[journey] instrumentAxios', () => {
         expect(emitMock.mock.calls[0][0].journey.outcome).toBe('good');
     });
 
+    test('marks request-aborted when axios reports a cancel', async () => {
+        getSharedPolicies().httpAbortedRequests = 'bad';
+        const axios = createAxiosMock();
+        instrumentAxios(axios);
+
+        moduleRuntime.startJourney(def);
+        await expect(
+            journeyStep(def.name, 'book-job', async () => {
+                const config = axios.requestHandlers[0]({ url: '/CallScreen/BookJob' });
+                (globalThis.performance.now as jest.Mock).mockReturnValue(1_020);
+                const cancelError: any = { config, name: 'CanceledError' };
+                cancelError.__CANCEL__ = true;
+                await axios.responseErrHandlers[0](cancelError);
+            })
+        ).rejects.toMatchObject({ name: 'CanceledError' });
+
+        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('network errors without a response status mark request-error', async () => {
         const axios = createAxiosMock();
         instrumentAxios(axios);

package/src/__tests__/integrations/expose-app-journey.test.ts

@@ -20,9 +20,15 @@ describe('[journey] exposeAppJourney', () => {
 
         expect(target.App).toBeDefined();
         expect(target.App.Journey).toBe(api);
+        expect(Object.isFrozen(target.App.Journey)).toBe(true);
+        expect(() => {
+            target.App.Journey.defineJourney = () => {
+                throw new Error('swapped');
+            };
+        }).toThrow();
         expect(typeof api.defineJourney).toBe('function');
         expect(typeof api.journeyStep).toBe('function');
-        expect(typeof api.firstOpenJourney).toBe('function');
+        expect(typeof api.firstOpenJourneyName).toBe('function');
     });
 
     test('preserves existing window.App properties', () => {
@@ -104,10 +110,10 @@ describe('[journey] exposeAppJourney', () => {
                 group: 'test',
                 service: 'test',
                 timeoutMs: 0,
-                steps: ['load'],
+                expected: ['load'],
             });
             bookJob.start();
-            expect(j.firstOpenJourney(['missing', 'ko-bridge-tags'])).toBe('ko-bridge-tags');
+            expect(j.firstOpenJourneyName(['missing', 'ko-bridge-tags'])).toBe('ko-bridge-tags');
 
             await bookJob.step('load', step => {
                 step.setAttribute('phase', 'load');