@servicetitan/journey 1.0.0

package/src/__tests__/runtime.test.ts

@@ -0,0 +1,273 @@
+/** @jest-environment jsdom */
+import { lastJourney, useJourneyTestRuntime } from '../__mocks__/test-runtime';
+import { configureJourney, getRequestTimeouts } from '../config';
+import {
+    activeJourneyStep,
+    completeJourney,
+    createJourneyRuntime,
+    defineJourney,
+    journeyStep,
+    resetJourney,
+    startJourney,
+} from '../core';
+import { sendToDatadog } from '../sinks/datadog';
+
+jest.mock('../sinks/datadog', () => ({
+    sendToDatadog: jest.fn(),
+}));
+
+const def = {
+    name: 'runtime-journey',
+    team: 't',
+    group: 'g',
+    service: 's',
+    timeoutMs: 0,
+};
+
+describe('[journey] resetJourney', () => {
+    const emitMock = jest.fn();
+
+    useJourneyTestRuntime(emitMock);
+
+    describe('when a journey is open', () => {
+        beforeEach(() => {
+            startJourney(def);
+        });
+
+        const subject = () => resetJourney({ sinks: [emitMock] });
+
+        test('clears it without emitting', () => {
+            subject();
+
+            expect(emitMock).not.toHaveBeenCalled();
+        });
+
+        test('makes later complete a no-op', () => {
+            subject();
+            completeJourney(def.name);
+
+            expect(emitMock).not.toHaveBeenCalled();
+        });
+    });
+
+    describe('when request timeouts were customized', () => {
+        beforeEach(() => {
+            configureJourney({ requestTimeouts: { defaultMs: 100, endpoints: [] } });
+        });
+
+        const subject = () => resetJourney({ sinks: [emitMock] });
+
+        test('restores the 4s default', () => {
+            subject();
+
+            expect(getRequestTimeouts().defaultMs).toBe(4_000);
+        });
+    });
+
+    describe('when reset passes custom requestTimeouts', () => {
+        const subject = () =>
+            resetJourney({
+                sinks: [emitMock],
+                requestTimeouts: { defaultMs: 250, endpoints: [] },
+            });
+
+        test('applies those timeouts', () => {
+            subject();
+
+            expect(getRequestTimeouts().defaultMs).toBe(250);
+        });
+    });
+
+    describe('when reset is called with no options', () => {
+        beforeEach(() => {
+            resetJourney({ sinks: [emitMock] });
+            emitMock.mockClear();
+            startJourney(def);
+            completeJourney(def.name);
+            emitMock.mockClear();
+        });
+
+        const subject = () => resetJourney();
+
+        test('leaves sinks empty', () => {
+            subject();
+            startJourney(def);
+            completeJourney(def.name);
+
+            expect(emitMock).not.toHaveBeenCalled();
+        });
+    });
+
+    describe('when a step is in flight', () => {
+        let resolveWork!: () => void;
+        let stepPromise: Promise<unknown>;
+
+        beforeEach(() => {
+            startJourney(def);
+            const hang = new Promise<void>(resolve => {
+                resolveWork = resolve;
+            });
+            stepPromise = journeyStep(def.name, 'slow', async () => {
+                await hang;
+            });
+        });
+
+        afterEach(async () => {
+            resolveWork();
+            await stepPromise.catch(() => {});
+        });
+
+        const subject = () => resetJourney({ sinks: [emitMock] });
+
+        test('clears the ambient step', () => {
+            expect(activeJourneyStep()).not.toBeNull();
+
+            subject();
+
+            expect(activeJourneyStep()).toBeNull();
+        });
+    });
+
+    describe('when a journey countdown is armed', () => {
+        beforeEach(() => {
+            jest.useFakeTimers();
+            startJourney({ ...def, timeoutMs: 50 });
+        });
+
+        afterEach(() => {
+            jest.useRealTimers();
+        });
+
+        const subject = () => resetJourney({ sinks: [emitMock] });
+
+        test('prevents the timer from emitting', async () => {
+            subject();
+            emitMock.mockClear();
+
+            await jest.advanceTimersByTimeAsync(50);
+
+            expect(emitMock).not.toHaveBeenCalled();
+        });
+    });
+});
+
+describe('[journey] createJourneyRuntime', () => {
+    const defaultEmit = jest.fn();
+    const isolatedEmit = jest.fn();
+    let runtime: ReturnType<typeof createJourneyRuntime>;
+
+    beforeEach(() => {
+        resetJourney({
+            sinks: [defaultEmit],
+            requestTimeouts: { defaultMs: 4_000, endpoints: [] },
+        });
+        defaultEmit.mockClear();
+        isolatedEmit.mockClear();
+        runtime = createJourneyRuntime({ sinks: [isolatedEmit] });
+    });
+
+    afterEach(() => {
+        resetJourney({
+            sinks: [sendToDatadog],
+            requestTimeouts: { defaultMs: 4_000, endpoints: [] },
+        });
+    });
+
+    describe('when both runtimes open a journey', () => {
+        beforeEach(() => {
+            runtime.startJourney(def);
+            startJourney({ ...def, name: 'default-side' });
+        });
+
+        const subject = () => {
+            runtime.completeJourney(def.name);
+            completeJourney('default-side');
+        };
+
+        test('emits only to the matching sink', () => {
+            subject();
+
+            expect(isolatedEmit.mock.calls[0][0].journey.name).toBe(def.name);
+            expect(defaultEmit.mock.calls[0][0].journey.name).toBe('default-side');
+        });
+    });
+
+    describe('when the isolated runtime has its own requestTimeouts', () => {
+        beforeEach(() => {
+            runtime = createJourneyRuntime({
+                sinks: [isolatedEmit],
+                requestTimeouts: { defaultMs: 10, endpoints: [] },
+            });
+            configureJourney({ requestTimeouts: { defaultMs: 9_000, endpoints: [] } });
+        });
+
+        test('keeps timeouts separate from the default engine', () => {
+            expect(runtime.getRequestTimeouts().defaultMs).toBe(10);
+            expect(getRequestTimeouts().defaultMs).toBe(9_000);
+        });
+    });
+
+    describe('when the isolated runtime is reset', () => {
+        beforeEach(() => {
+            runtime.startJourney(def);
+            startJourney({ ...def, name: 'default-side' });
+        });
+
+        const subject = () => runtime.reset({ sinks: [isolatedEmit] });
+
+        test('does not clear the default engine', () => {
+            subject();
+            completeJourney('default-side');
+
+            expect(defaultEmit).toHaveBeenCalledTimes(1);
+            expect(lastJourney(defaultEmit).name).toBe('default-side');
+        });
+    });
+
+    describe('when defineJourney is used', () => {
+        const subject = () =>
+            defineJourney(def).step('load', step => {
+                step.complete();
+            });
+
+        test('binds to the default runtime', async () => {
+            await subject();
+
+            expect(defaultEmit).toHaveBeenCalledTimes(1);
+            expect(lastJourney(defaultEmit).name).toBe(def.name);
+            expect(isolatedEmit).not.toHaveBeenCalled();
+        });
+    });
+
+    describe('when a throwing sink is registered on the isolated runtime', () => {
+        let second: jest.Mock;
+
+        beforeEach(() => {
+            second = jest.fn();
+            runtime.setSinks([
+                () => {
+                    throw new Error('boom');
+                },
+                second,
+            ]);
+            runtime.startJourney(def);
+        });
+
+        const subject = () => runtime.completeJourney(def.name);
+
+        test('still invokes later sinks', () => {
+            expect(() => subject()).not.toThrow();
+            expect(second).toHaveBeenCalledTimes(1);
+        });
+    });
+
+    describe('with create-time options', () => {
+        test('installs the initial sinks', () => {
+            const created = createJourneyRuntime({ sinks: [isolatedEmit] });
+            created.startJourney(def);
+            created.completeJourney(def.name);
+
+            expect(isolatedEmit).toHaveBeenCalledTimes(1);
+        });
+    });
+});

package/src/__tests__/scope.test.tsx

@@ -0,0 +1,128 @@
+/** @jest-environment jsdom */
+import { render, screen } from '@testing-library/react';
+import { useContext } from 'react';
+
+import { useJourneyTestRuntime } from '../__mocks__/test-runtime';
+import { completeJourney, failJourney } from '../core';
+import { JourneyNameContext } from '../integrations/react/context';
+import { JourneyScope } from '../integrations/react/scope';
+
+const emitMock = jest.fn();
+
+const def = {
+    name: 'scope-journey',
+    team: 'platform',
+    group: 'test',
+    service: 'journey',
+    timeoutMs: 0,
+};
+
+function NameProbe() {
+    const name = useContext(JourneyNameContext);
+    return <span data-testid="journey-name">{name}</span>;
+}
+
+describe('[journey] JourneyScope', () => {
+    useJourneyTestRuntime(emitMock);
+
+    test('opens a journey on mount and publishes the name via context', () => {
+        render(
+            <JourneyScope {...def}>
+                <NameProbe />
+            </JourneyScope>
+        );
+
+        expect(screen.getByTestId('journey-name').textContent).toBe(def.name);
+        completeJourney(def.name);
+        expect(emitMock).toHaveBeenCalledTimes(1);
+        expect(emitMock.mock.calls[0][0].journey.outcome).toBe('good');
+    });
+
+    test('applies tags from props', () => {
+        render(
+            <JourneyScope {...def} tags={{ plan: 'pro' }}>
+                <NameProbe />
+            </JourneyScope>
+        );
+
+        completeJourney(def.name);
+        expect(emitMock.mock.calls[0][0].journey.tags).toEqual({ plan: 'pro' });
+    });
+
+    test('excludes the journey on unmount', () => {
+        const { unmount } = render(
+            <JourneyScope {...def}>
+                <NameProbe />
+            </JourneyScope>
+        );
+
+        unmount();
+
+        expect(emitMock).toHaveBeenCalledTimes(1);
+        expect(emitMock.mock.calls[0][0].journey.outcome).toBe('excluded');
+    });
+
+    describe('when the journey already completed before unmount', () => {
+        test('unmount does not emit again', () => {
+            const { unmount } = render(
+                <JourneyScope {...def}>
+                    <NameProbe />
+                </JourneyScope>
+            );
+
+            completeJourney(def.name);
+            expect(emitMock).toHaveBeenCalledTimes(1);
+            expect(emitMock.mock.calls[0][0].journey.outcome).toBe('good');
+
+            emitMock.mockClear();
+            unmount();
+
+            expect(emitMock).not.toHaveBeenCalled();
+        });
+    });
+
+    describe('when the name prop changes', () => {
+        const next = { ...def, name: 'scope-journey-next' };
+
+        test('excludes the prior journey and opens the new one', () => {
+            const { rerender } = render(
+                <JourneyScope {...def}>
+                    <NameProbe />
+                </JourneyScope>
+            );
+
+            rerender(
+                <JourneyScope {...next}>
+                    <NameProbe />
+                </JourneyScope>
+            );
+
+            expect(screen.getByTestId('journey-name').textContent).toBe(next.name);
+            expect(emitMock).toHaveBeenCalledTimes(1);
+            expect(emitMock.mock.calls[0][0].journey.name).toBe(def.name);
+            expect(emitMock.mock.calls[0][0].journey.outcome).toBe('excluded');
+
+            completeJourney(next.name);
+            expect(emitMock.mock.calls[1][0].journey.name).toBe(next.name);
+            expect(emitMock.mock.calls[1][0].journey.outcome).toBe('good');
+        });
+    });
+
+    describe('when a breach already occurred before unmount', () => {
+        test('unmount stays bad (breach-anchored)', () => {
+            const { unmount } = render(
+                <JourneyScope {...def}>
+                    <NameProbe />
+                </JourneyScope>
+            );
+
+            failJourney(def.name, 'validation');
+            expect(emitMock.mock.calls[0][0].journey.outcome).toBe('bad');
+
+            emitMock.mockClear();
+            unmount();
+
+            expect(emitMock).not.toHaveBeenCalled();
+        });
+    });
+});

package/src/__tests__/sinks.test.ts

@@ -0,0 +1,99 @@
+/** @jest-environment jsdom */
+jest.mock('../sinks/datadog', () => ({
+    sendToDatadog: jest.fn(),
+}));
+
+import { resetJourney } from '../core';
+import { addJourneySink, emitJourneyEvent, setJourneySinks } from '../core/registry';
+import type { JourneyEvent } from '../core/types';
+import { sendToDatadog } from '../sinks/datadog';
+
+describe('[journey] emitJourneyEvent', () => {
+    let payload: JourneyEvent;
+
+    beforeEach(() => {
+        jest.mocked(sendToDatadog).mockClear();
+        resetJourney({ sinks: [sendToDatadog] });
+        payload = {
+            journey: {
+                name: 'test',
+                team: 't',
+                group: 'g',
+                service: 's',
+                outcome: 'good',
+                durationMs: 1,
+                steps: [],
+            },
+        };
+    });
+
+    afterEach(() => {
+        resetJourney({ sinks: [sendToDatadog] });
+    });
+
+    const subject = () => emitJourneyEvent(payload);
+
+    test('forwards the payload to each configured sink', () => {
+        subject();
+
+        expect(sendToDatadog).toHaveBeenCalledWith(payload);
+    });
+
+    describe('with an additional sink', () => {
+        let extra: jest.Mock;
+
+        beforeEach(() => {
+            extra = jest.fn();
+            addJourneySink(extra);
+        });
+
+        test('invokes every configured sink', () => {
+            subject();
+
+            expect(sendToDatadog).toHaveBeenCalledWith(payload);
+            expect(extra).toHaveBeenCalledWith(payload);
+        });
+
+        test('continues to later sinks when one throws', () => {
+            setJourneySinks([
+                () => {
+                    throw new Error('boom');
+                },
+                sendToDatadog,
+                extra,
+            ]);
+
+            expect(() => subject()).not.toThrow();
+            expect(sendToDatadog).toHaveBeenCalledWith(payload);
+            expect(extra).toHaveBeenCalledWith(payload);
+        });
+    });
+
+    describe('when sinks are replaced', () => {
+        let only: jest.Mock;
+
+        beforeEach(() => {
+            only = jest.fn();
+            setJourneySinks([only]);
+        });
+
+        test('does not call the previous sinks', () => {
+            subject();
+
+            expect(only).toHaveBeenCalledWith(payload);
+            expect(sendToDatadog).not.toHaveBeenCalled();
+        });
+    });
+
+    describe('with an empty sink list', () => {
+        beforeEach(() => {
+            setJourneySinks([]);
+        });
+
+        test('emits nowhere', () => {
+            subject();
+
+            expect(sendToDatadog).not.toHaveBeenCalled();
+        });
+    });
+});