@servicetitan/journey 2.1.0 → 3.0.0

package/src/__tests__/integrations/jquery.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 { instrumentJquery } from '../../integrations/jquery/instrument';
 
 const emitMock = jest.fn();
@@ -60,6 +61,87 @@ describe('[journey] instrumentJquery', () => {
         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($);
@@ -70,7 +152,7 @@ describe('[journey] instrumentJquery', () => {
             group: 'test',
             service: 'test',
             timeoutMs: 0,
-            requestTimeoutMs: 50,
+            slowRequestMs: 50,
         });
 
         simulateAjax($, '/CallScreen/BookJob', 500);
@@ -80,7 +162,66 @@ describe('[journey] instrumentJquery', () => {
         expect(emitMock.mock.calls[0][0].journey.outcome).toBe('good');
     });
 
-    test('stamped journeyStep is JSON-safe on jqXHR and ajax settings', async () => {
+    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($);
 
@@ -90,28 +231,30 @@ describe('[journey] instrumentJquery', () => {
             group: 'test',
             service: 'test',
             timeoutMs: 0,
-            requestTimeoutMs: 5_000,
+            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;
-                journeyStep?: unknown;
+                stamp?: unknown;
                 journeyStart?: number;
             } = { status: 200 };
             const ambientSettings = { url: '/CallScreen/BookJob' };
             for (const prefilter of $.__prefilters) {
                 prefilter(ambientSettings, ambientSettings, ambientXhr);
             }
-            expect(ambientXhr.journeyStep).toBeInstanceOf(JourneyStepTag);
-            expect(JSON.parse(JSON.stringify(ambientXhr)).journeyStep).toBe('[JourneyStepTag]');
-
-            // Explicit step.tag() spread into ajax settings — same circular risk.
-            const tagged = step.tag() as { journeyStep: unknown };
-            const settings = { url: '/CallScreen/BookJob', ...tagged };
-            expect(settings.journeyStep).toBeInstanceOf(JourneyStepTag);
-            expect(JSON.parse(JSON.stringify(settings)).journeyStep).toBe('[JourneyStepTag]');
+            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');
     });
@@ -126,7 +269,7 @@ describe('[journey] instrumentJquery', () => {
             group: 'test',
             service: 'test',
             timeoutMs: 0,
-            requestTimeoutMs: 5_000,
+            slowRequestMs: 5_000,
         });
 
         await journeyStep('jq-5xx', 'book-job', () => {
@@ -149,7 +292,7 @@ describe('[journey] instrumentJquery', () => {
             group: 'test',
             service: 'test',
             timeoutMs: 0,
-            requestTimeoutMs: 50,
+            slowRequestMs: 50,
         });
 
         await journeyStep('jq-slow', 'book-job', () => {
@@ -172,7 +315,7 @@ describe('[journey] instrumentJquery', () => {
             group: 'test',
             service: 'test',
             timeoutMs: 0,
-            requestTimeoutMs: 5_000,
+            slowRequestMs: 5_000,
         });
 
         await journeyStep('jq-network', 'book-job', () => {
@@ -194,7 +337,7 @@ describe('[journey] instrumentJquery', () => {
             group: 'test',
             service: 'test',
             timeoutMs: 0,
-            requestTimeoutMs: 5_000,
+            slowRequestMs: 5_000,
         });
 
         await journeyStep('jq-4xx', 'book-job', () => {
@@ -206,7 +349,39 @@ describe('[journey] instrumentJquery', () => {
         expect(emitMock.mock.calls[0][0].journey.outcome).toBe('good');
     });
 
-    test('honors an explicit journeyStep already stamped on the XHR', async () => {
+    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($);
 
@@ -216,23 +391,23 @@ describe('[journey] instrumentJquery', () => {
             group: 'test',
             service: 'test',
             timeoutMs: 0,
-            requestTimeoutMs: 5_000,
+            slowRequestMs: 5_000,
         });
 
         await journeyStep('jq-explicit', 'book-job', step => {
-            const tagged = step.tag() as { journeyStep: unknown };
+            const tagged = step.stamp();
             const xhr: {
                 status: number;
-                journeyStep: unknown;
+                stamp: unknown;
                 journeyStart?: number;
-            } = { status: 500, journeyStep: tagged.journeyStep };
+            } = { 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.journeyStep).toBe(tagged.journeyStep);
+            expect(xhr.stamp).toBeUndefined();
             expect(xhr.journeyStart).toBeDefined();
             (globalThis.performance.now as jest.Mock).mockReturnValue(start + 20);
             for (const complete of $.__completes) {
@@ -255,13 +430,13 @@ describe('[journey] instrumentJquery', () => {
             group: 'test',
             service: 'test',
             timeoutMs: 0,
-            requestTimeoutMs: 5_000,
+            slowRequestMs: 5_000,
         });
 
         await journeyStep('jq-no-start', 'book-job', step => {
-            const tagged = step.tag() as { journeyStep: unknown };
+            const tagged = step.stamp();
             // Bypass prefilter stamping — only fire ajaxComplete with a step and no start.
-            const xhr = { status: 200, journeyStep: tagged.journeyStep };
+            const xhr = { status: 200, stamp: tagged };
             for (const complete of $.__completes) {
                 complete({}, xhr, { url: '/ok' });
             }
@@ -272,7 +447,7 @@ describe('[journey] instrumentJquery', () => {
         expect(emitMock.mock.calls[0][0].journey.outcome).toBe('good');
     });
 
-    test('honors step.tag() on ajax settings without deep-merge stack overflow', async () => {
+    test('honors step.stamp() on ajax settings without deep-merge stack overflow', async () => {
         const $ = createJqueryMock();
         instrumentJquery($);
 
@@ -312,21 +487,21 @@ describe('[journey] instrumentJquery', () => {
             group: 'test',
             service: 'test',
             timeoutMs: 0,
-            requestTimeoutMs: 5_000,
+            slowRequestMs: 5_000,
         });
 
         await journeyStep('jq-settings-tag', 'book-job', step => {
-            const tagged = step.tag() as { journeyStep: unknown };
-            expect(() => deepExtend({}, tagged)).not.toThrow();
-            const settings = deepExtend({ url: '/CallScreen/BookJob' }, tagged);
-            const xhr: { status: number; journeyStep?: unknown; journeyStart?: number } = {
+            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.journeyStep).toBe(tagged.journeyStep);
+            expect(xhr.stamp).toBeUndefined();
             (globalThis.performance.now as jest.Mock).mockReturnValue(start + 20);
             for (const complete of $.__completes) {
                 complete({}, xhr, settings);
@@ -348,7 +523,7 @@ describe('[journey] instrumentJquery', () => {
             group: 'test',
             service: 'test',
             timeoutMs: 0,
-            requestTimeoutMs: 5_000,
+            slowRequestMs: 5_000,
             endpoints: [{ match: 'pdf.vendor.com/render', ignore: true }],
         });
 

package/src/__tests__/integrations/scope.test.tsx

@@ -1,9 +1,10 @@
 /** @jest-environment jsdom */
 import { render, screen } from '@testing-library/react';
-import { useContext } from 'react';
+import { useContext, useEffect } from 'react';
 
 import { useJourneyTestRuntime } from '../../__test-utils__/test-runtime';
-import { completeJourney, failJourney } from '../../core';
+import { completeJourney, failJourney, journeyStep } from '../../core';
+import { onHttpComplete } from '../../integrations/http-report';
 import { JourneyNameContext } from '../../integrations/react/context';
 import { JourneyScope } from '../../integrations/react/scope';
 
@@ -25,6 +26,14 @@ function NameProbe() {
 describe('[journey] JourneyScope', () => {
     useJourneyTestRuntime(emitMock);
 
+    beforeEach(() => {
+        jest.useFakeTimers();
+    });
+
+    afterEach(() => {
+        jest.useRealTimers();
+    });
+
     test('opens a journey on mount and publishes the name via context', () => {
         render(
             <JourneyScope {...def}>
@@ -125,4 +134,153 @@ describe('[journey] JourneyScope', () => {
             expect(emitMock).not.toHaveBeenCalled();
         });
     });
+
+    test('applies updated tags without restarting', () => {
+        const { rerender } = render(
+            <JourneyScope {...def} tags={{ plan: 'a' }}>
+                <NameProbe />
+            </JourneyScope>
+        );
+
+        rerender(
+            <JourneyScope {...def} tags={{ plan: 'b' }}>
+                <NameProbe />
+            </JourneyScope>
+        );
+
+        completeJourney(def.name);
+        expect(emitMock).toHaveBeenCalledTimes(1);
+        expect(emitMock.mock.calls[0][0].journey.tags).toEqual({ plan: 'b' });
+        expect(emitMock.mock.calls[0][0].journey.outcome).toBe('good');
+    });
+
+    test('child abort cleanup then unmount is excluded not request-aborted', async () => {
+        let stamp: Parameters<typeof onHttpComplete>[0]['stamp'];
+        let release!: () => void;
+        const hang = new Promise<void>(resolve => {
+            release = resolve;
+        });
+
+        function Child() {
+            useEffect(
+                () => () => {
+                    if (stamp) {
+                        onHttpComplete({
+                            stamp,
+                            aborted: true,
+                            requestKey: '/x',
+                            durationMs: 5,
+                        });
+                    }
+                },
+                []
+            );
+            return null;
+        }
+
+        const { unmount } = render(
+            <JourneyScope {...def}>
+                <Child />
+            </JourneyScope>
+        );
+
+        const stepPromise = journeyStep(def.name, 'load', async step => {
+            stamp = step.stamp();
+            await hang;
+        });
+        await Promise.resolve();
+        unmount();
+
+        expect(emitMock).toHaveBeenCalledTimes(1);
+        expect(emitMock.mock.calls[0][0].journey.outcome).toBe('excluded');
+
+        release();
+        await stepPromise;
+    });
+
+    test('rerendering with equal endpoint values does not re-arm timeout', async () => {
+        const timeoutDef = {
+            ...def,
+            name: 'scope-timer-stable',
+            timeoutMs: 30,
+            endpoints: [{ match: '/api/jobs', slowRequestMs: 100 }],
+        };
+
+        const { rerender } = render(
+            <JourneyScope {...timeoutDef}>
+                <NameProbe />
+            </JourneyScope>
+        );
+
+        await jest.advanceTimersByTimeAsync(20);
+
+        rerender(
+            <JourneyScope {...timeoutDef} endpoints={[{ match: '/api/jobs', slowRequestMs: 100 }]}>
+                <NameProbe />
+            </JourneyScope>
+        );
+
+        await jest.advanceTimersByTimeAsync(15);
+
+        expect(emitMock).toHaveBeenCalledTimes(1);
+        expect(emitMock.mock.calls[0][0].journey.outcome).toBe('bad');
+        expect(emitMock.mock.calls[0][0].journey.reason).toBe('journey-timeout');
+    });
+
+    test('live config updates keep original timeout budget', async () => {
+        const timeoutDef = {
+            ...def,
+            name: 'scope-timeout-updates',
+            timeoutMs: 30,
+            team: 'team-a',
+        };
+
+        const { rerender } = render(
+            <JourneyScope {...timeoutDef}>
+                <NameProbe />
+            </JourneyScope>
+        );
+
+        await jest.advanceTimersByTimeAsync(20);
+
+        rerender(
+            <JourneyScope {...timeoutDef} team="team-b">
+                <NameProbe />
+            </JourneyScope>
+        );
+
+        await jest.advanceTimersByTimeAsync(15);
+
+        expect(emitMock).toHaveBeenCalledTimes(1);
+        expect(emitMock.mock.calls[0][0].journey.name).toBe(timeoutDef.name);
+        expect(emitMock.mock.calls[0][0].journey.reason).toBe('journey-timeout');
+    });
+
+    test('live maxSteps updates apply without restarting', async () => {
+        const maxStepsDef = {
+            ...def,
+            name: 'scope-max-steps',
+            maxSteps: 1,
+        };
+
+        const { rerender } = render(
+            <JourneyScope {...maxStepsDef}>
+                <NameProbe />
+            </JourneyScope>
+        );
+
+        await journeyStep(maxStepsDef.name, 'first', async () => {});
+
+        rerender(
+            <JourneyScope {...maxStepsDef} maxSteps={2}>
+                <NameProbe />
+            </JourneyScope>
+        );
+
+        await journeyStep(maxStepsDef.name, 'second', async () => {});
+
+        completeJourney(maxStepsDef.name);
+        expect(emitMock).toHaveBeenCalledTimes(1);
+        expect(emitMock.mock.calls[0][0].journey.steps).toHaveLength(2);
+    });
 });

package/src/__tests__/integrations/use-journey-step.test.tsx

@@ -0,0 +1,43 @@
+/** @jest-environment jsdom */
+import { renderHook } from '@testing-library/react';
+import { type ReactNode } from 'react';
+
+import {
+    useJourneyTestRuntime,
+    baseJourneyDef,
+    lastJourney,
+} from '../../__test-utils__/test-runtime';
+import { completeJourney, defineJourney } from '../../core';
+import { JourneyScope } from '../../integrations/react/scope';
+import { useJourneyStep } from '../../integrations/react/use-journey-step';
+
+const emitMock = jest.fn();
+
+describe('[journey] useJourneyStep', () => {
+    useJourneyTestRuntime(emitMock);
+
+    test('runs a step on the JourneyScope journey', async () => {
+        const wrapper = ({ children }: { children: ReactNode }) => (
+            <JourneyScope {...baseJourneyDef} name="hook-journey">
+                {children}
+            </JourneyScope>
+        );
+
+        const { result } = renderHook(() => useJourneyStep(), { wrapper });
+        await result.current('load', () => 'ok');
+        completeJourney('hook-journey');
+
+        expect(lastJourney(emitMock).steps[0].name).toBe('load');
+        expect(lastJourney(emitMock).outcome).toBe('good');
+    });
+
+    test('auto-starts when given a handle', async () => {
+        const handle = defineJourney({ ...baseJourneyDef, name: 'hook-handle' });
+        const { result } = renderHook(() => useJourneyStep(handle));
+        await result.current('load', () => 'ok');
+        handle.complete();
+
+        expect(lastJourney(emitMock).steps[0].name).toBe('load');
+        expect(lastJourney(emitMock).outcome).toBe('good');
+    });
+});

package/src/__tests__/sinks/console.test.ts

@@ -23,12 +23,14 @@ describe('[journey] sendToConsole / isJourneyDebugEnabled', () => {
 
     beforeEach(() => {
         localStorage.clear();
+        sessionStorage.clear();
         debugSpy = jest.spyOn(console, 'debug').mockImplementation(() => undefined);
     });
 
     afterEach(() => {
         debugSpy.mockRestore();
         localStorage.clear();
+        sessionStorage.clear();
     });
 
     describe('when st:journey:debug is not set', () => {
@@ -45,7 +47,7 @@ describe('[journey] sendToConsole / isJourneyDebugEnabled', () => {
 
     describe('when st:journey:debug is a non-true value', () => {
         beforeEach(() => {
-            localStorage.setItem(JOURNEY_DEBUG_STORAGE_KEY, '1');
+            sessionStorage.setItem(JOURNEY_DEBUG_STORAGE_KEY, '1');
         });
 
         test('isJourneyDebugEnabled is false', () => {
@@ -61,7 +63,7 @@ describe('[journey] sendToConsole / isJourneyDebugEnabled', () => {
 
     describe('when st:journey:debug is true', () => {
         beforeEach(() => {
-            localStorage.setItem(JOURNEY_DEBUG_STORAGE_KEY, 'true');
+            sessionStorage.setItem(JOURNEY_DEBUG_STORAGE_KEY, 'true');
         });
 
         test('isJourneyDebugEnabled is true', () => {
@@ -74,11 +76,14 @@ describe('[journey] sendToConsole / isJourneyDebugEnabled', () => {
             sendToConsole(event);
 
             expect(debugSpy).toHaveBeenCalledTimes(1);
-            expect(debugSpy).toHaveBeenCalledWith('[journey] Book Job → bad', event.journey);
+            expect(debugSpy).toHaveBeenCalledWith(
+                '[journey] book_job → bad',
+                expect.objectContaining({ name: 'book_job', outcome: 'bad' })
+            );
         });
     });
 
-    describe('when localStorage throws', () => {
+    describe('when sessionStorage throws', () => {
         beforeEach(() => {
             jest.spyOn(Storage.prototype, 'getItem').mockImplementation(() => {
                 throw new Error('denied');