@servicetitan/journey 2.1.0 → 3.0.0

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

@@ -1,18 +1,27 @@
 /** @jest-environment jsdom */
-import { activeJourneyStep, reportBackendRequest, type JourneyStepRef } from '../../core';
+import { resolveStamp, JourneyStepStamp } from '../../core';
+import type { StepRecord } from '../../core/types';
 import { instrumentFetch, type InstrumentFetchOptions } from '../../integrations/fetch';
+import { onHttpComplete } from '../../integrations/http-report';
 import { requestKey } from '../../integrations/request-key';
 
 jest.mock('../../core', () => ({
     ...jest.requireActual('../../core'),
-    activeJourneyStep: jest.fn(),
-    reportBackendRequest: jest.fn(),
+    resolveStamp: jest.fn(),
+}));
+jest.mock('../../integrations/http-report', () => ({
+    ...jest.requireActual('../../integrations/http-report'),
+    onHttpComplete: jest.fn(),
 }));
 jest.mock('../../integrations/request-key');
 
 describe('[journey] instrumentFetch', () => {
     const KEY = 'resolved-endpoint-key';
-    const step = { name: 'load' } as unknown as JourneyStepRef;
+    const record = {
+        name: 'load',
+        journey: { name: 'j', closed: false },
+    } as unknown as StepRecord;
+    const stamp = new JourneyStepStamp(record);
 
     let target: { fetch: jest.Mock };
     let originalFetch: jest.Mock;
@@ -33,10 +42,9 @@ describe('[journey] instrumentFetch', () => {
         init = undefined;
         options = { target };
 
-        jest.mocked(activeJourneyStep).mockReturnValue(step);
+        jest.mocked(resolveStamp).mockReturnValue(stamp);
         jest.mocked(requestKey).mockReturnValue(KEY);
 
-        // Deterministic clock: each globalThis.performance.now() advances by 100ms.
         now = 1_000;
         jest.spyOn(globalThis.performance, 'now').mockImplementation(() => (now += 100));
     });
@@ -70,9 +78,53 @@ describe('[journey] instrumentFetch', () => {
 
         await target.fetch(input, init);
         expect(originalFetch).toHaveBeenCalledTimes(1);
-        expect(reportBackendRequest).toHaveBeenCalledTimes(1);
+        expect(onHttpComplete).toHaveBeenCalledTimes(1);
     });
 
+    test('warns and soft-skips when options are null', () => {
+        const warn = jest.spyOn(console, 'warn').mockImplementation(() => {});
+        const error = jest.spyOn(console, 'error').mockImplementation(() => {});
+
+        const restore = instrumentFetch(null);
+
+        expect(() => restore()).not.toThrow();
+        expect(warn).toHaveBeenCalledWith(
+            expect.stringContaining('[journey] instrumentFetch: skipped — missing')
+        );
+        expect(error).not.toHaveBeenCalled();
+        expect(target.fetch).toBe(originalFetch);
+    });
+
+    test('warns and soft-skips when target is null', () => {
+        const warn = jest.spyOn(console, 'warn').mockImplementation(() => {});
+        const error = jest.spyOn(console, 'error').mockImplementation(() => {});
+
+        const restore = instrumentFetch({ target: null });
+
+        expect(() => restore()).not.toThrow();
+        expect(warn).toHaveBeenCalledWith(
+            expect.stringContaining('[journey] instrumentFetch: skipped — missing')
+        );
+        expect(error).not.toHaveBeenCalled();
+    });
+
+    test.each([{}, { fetch: 1 }, { fetch: undefined }])(
+        'errors and soft-skips when target has invalid shape (%p)',
+        bad => {
+            const warn = jest.spyOn(console, 'warn').mockImplementation(() => {});
+            const error = jest.spyOn(console, 'error').mockImplementation(() => {});
+
+            const restore = instrumentFetch({ target: bad as never });
+
+            expect(() => restore()).not.toThrow();
+            expect(error).toHaveBeenCalledWith(
+                expect.stringContaining('[journey] instrumentFetch: skipped — invalid shape (')
+            );
+            expect(error.mock.calls[0]).toHaveLength(1);
+            expect(warn).not.toHaveBeenCalled();
+        }
+    );
+
     test('delegates to the original fetch with the same arguments', async () => {
         init = { method: 'POST' };
 
@@ -90,16 +142,51 @@ describe('[journey] instrumentFetch', () => {
     test('reports the finished request against the active step', async () => {
         await subject();
 
-        expect(reportBackendRequest).toHaveBeenCalledWith(step, 200, 100, KEY);
+        expect(onHttpComplete).toHaveBeenCalledWith(
+            expect.objectContaining({
+                stamp,
+                status: 200,
+                durationMs: 100,
+                requestKey: KEY,
+                method: 'GET',
+            })
+        );
+    });
+
+    test('reports method from init', async () => {
+        init = { method: 'POST' };
+
+        await subject();
+
+        expect(onHttpComplete).toHaveBeenCalledWith(
+            expect.objectContaining({ method: 'POST', status: 200, requestKey: KEY })
+        );
+    });
+
+    test('reports the Request method when init has none', async () => {
+        input = new Request('https://api.example.com/orders', { method: 'PUT' });
+
+        await subject();
+
+        expect(onHttpComplete).toHaveBeenCalledWith(expect.objectContaining({ method: 'PUT' }));
+    });
+
+    test('prefers init.method over the Request method', async () => {
+        input = new Request('https://api.example.com/orders', { method: 'PUT' });
+        init = { method: 'PATCH' };
+
+        await subject();
+
+        expect(onHttpComplete).toHaveBeenCalledWith(expect.objectContaining({ method: 'PATCH' }));
     });
 
     describe('when no journey step is active', () => {
-        beforeEach(() => jest.mocked(activeJourneyStep).mockReturnValue(null));
+        beforeEach(() => jest.mocked(resolveStamp).mockReturnValue(undefined));
 
         test('does not report the request', async () => {
             await subject();
 
-            expect(reportBackendRequest).not.toHaveBeenCalled();
+            expect(onHttpComplete).not.toHaveBeenCalled();
         });
 
         test('still delegates to the original fetch', async () => {
@@ -112,8 +199,12 @@ describe('[journey] instrumentFetch', () => {
     describe('when the active step changes before the response settles', () => {
         beforeEach(() => {
             originalFetch.mockImplementation(() => {
-                // The step captured at call time must win over whatever is active later.
-                jest.mocked(activeJourneyStep).mockReturnValue({ name: 'other' } as JourneyStepRef);
+                jest.mocked(resolveStamp).mockReturnValue(
+                    new JourneyStepStamp({
+                        name: 'other',
+                        journey: { name: 'j2', closed: false },
+                    } as unknown as StepRecord)
+                );
                 return Promise.resolve(response);
             });
         });
@@ -121,7 +212,9 @@ describe('[journey] instrumentFetch', () => {
         test('reports against the step captured at call time', async () => {
             await subject();
 
-            expect(reportBackendRequest).toHaveBeenCalledWith(step, 200, 100, KEY);
+            expect(onHttpComplete).toHaveBeenCalledWith(
+                expect.objectContaining({ stamp, status: 200, requestKey: KEY })
+            );
         });
     });
 
@@ -137,7 +230,15 @@ describe('[journey] instrumentFetch', () => {
         test('reports the failure with an undefined status', async () => {
             await subject().catch(() => {});
 
-            expect(reportBackendRequest).toHaveBeenCalledWith(step, undefined, 100, KEY);
+            expect(onHttpComplete).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    stamp,
+                    status: undefined,
+                    durationMs: 100,
+                    requestKey: KEY,
+                    aborted: false,
+                })
+            );
         });
     });
 
@@ -200,18 +301,51 @@ describe('[journey] instrumentFetch', () => {
         });
     });
 
-    describe('when init carries an explicit journeyStep', () => {
-        const explicit = { name: 'explicit' } as unknown as JourneyStepRef;
+    describe('when init carries an explicit stamp', () => {
+        const explicit = new JourneyStepStamp({
+            name: 'explicit',
+            journey: { name: 'j', closed: false },
+        } as unknown as StepRecord);
 
         beforeEach(() => {
-            init = { journeyStep: explicit } as RequestInit;
-            jest.mocked(activeJourneyStep).mockReturnValue(step);
+            init = { stamp: explicit } as RequestInit;
+            jest.mocked(resolveStamp).mockImplementation(value => (value ? explicit : stamp));
         });
 
         test('prefers the explicit step over ambient', async () => {
             await subject();
 
-            expect(reportBackendRequest).toHaveBeenCalledWith(explicit, 200, 100, KEY);
+            expect(onHttpComplete).toHaveBeenCalledWith(
+                expect.objectContaining({ stamp: explicit, status: 200, requestKey: KEY })
+            );
+        });
+    });
+
+    describe('when init.ignore is true', () => {
+        beforeEach(() => {
+            init = { ignore: true } as RequestInit;
+        });
+
+        test('does not report the request', async () => {
+            await subject();
+
+            expect(onHttpComplete).not.toHaveBeenCalled();
+            expect(originalFetch).toHaveBeenCalledWith(input, init);
+        });
+    });
+
+    describe('when the stamp is ignore', () => {
+        beforeEach(() => {
+            jest.mocked(resolveStamp).mockReturnValue(
+                new JourneyStepStamp(record, { ignore: true })
+            );
+        });
+
+        test('does not report the request', async () => {
+            await subject();
+
+            expect(onHttpComplete).not.toHaveBeenCalled();
+            expect(originalFetch).toHaveBeenCalledWith(input, init);
         });
     });