@unifygtm/intent-client/src/tests/client/managers/sessions.unit.test.ts

JavaScript client for interacting with the Unify Intent API in the browser.

import { anyNumber, mock, mockReset } from 'jest-mock-extended';

import {
  LEGACY_SESSION_STORAGE_KEY,
  SESSION_ID_STORAGE_KEY,
  SESSION_STORAGE_KEY,
  SessionManager,
} from '../../../client/managers';
import {
  CookieStorageService,
  LocalStorageService,
} from '../../../client/storage';
import type { ClientSession } from '../../../types';
import { MockClientSession, TEST_WRITE_KEY } from '../../mocks/data';

const localStorageMock = mock(LocalStorageService.prototype);
const cookieStorageMock = mock(CookieStorageService.prototype);

jest.mock('../../../client/storage', () => ({
  ...jest.requireActual('../../../client/storage'),
  LocalStorageService: jest.fn().mockImplementation(() => localStorageMock),
  CookieStorageService: jest.fn().mockImplementation(() => cookieStorageMock),
}));

describe('SessionManager', () => {
  beforeEach(() => {
    mockReset(localStorageMock);
    mockReset(cookieStorageMock);
  });

  describe('getOrCreateSession', () => {
    it('creates a new session if none exists', () => {
      const sessionManager = new SessionManager(TEST_WRITE_KEY);
      const result = sessionManager.getOrCreateSession();

      expect(localStorageMock.get).toHaveBeenCalledWith(SESSION_STORAGE_KEY);
      expect(localStorageMock.get).toHaveBeenCalledWith(
        LEGACY_SESSION_STORAGE_KEY,
      );
      expect(localStorageMock.set).toHaveBeenCalledWith(
        SESSION_STORAGE_KEY,
        result,
      );
      expect(cookieStorageMock.set).toHaveBeenCalledWith(
        SESSION_ID_STORAGE_KEY,
        result.sessionId,
      );
    });

    describe('when a session already exists', () => {
      let mockSession: ClientSession;

      describe('when the session is not expired', () => {
        beforeEach(() => {
          const tenMinutesFromNow = new Date();
          tenMinutesFromNow.setMinutes(tenMinutesFromNow.getMinutes() + 10);
          mockSession = MockClientSession({
            expiration: tenMinutesFromNow.getTime(),
          });
          localStorageMock.get.mockReturnValueOnce(mockSession);
        });

        it('updates the session expiration time and returns it', () => {
          const sessionManager = new SessionManager(TEST_WRITE_KEY);
          const session = sessionManager.getOrCreateSession();

          const expectedSession = {
            ...mockSession,
            expiration: anyNumber(),
          };

          expect(localStorageMock.set).toHaveBeenCalledTimes(1);
          expect(localStorageMock.set).toHaveBeenCalledWith(
            SESSION_STORAGE_KEY,
            expectedSession,
          );
          expect(cookieStorageMock.set).toHaveBeenCalledWith(
            SESSION_ID_STORAGE_KEY,
            expectedSession.sessionId,
          );
          expect(session.expiration).toBeGreaterThan(mockSession.expiration);
        });

        it('gets the cached session if it exists, but still updates session', () => {
          // Initialize cached value
          localStorageMock.get.mockReturnValueOnce(mockSession);
          const sessionManager = new SessionManager(TEST_WRITE_KEY);
          sessionManager.getOrCreateSession();

          // Clear mock so we can test fresh state
          localStorageMock.get.mockClear();
          localStorageMock.set.mockClear();

          // Check that cached value exists
          const session = sessionManager.getOrCreateSession();
          expect(session).toEqual({
            ...mockSession,
            expiration: anyNumber(),
          });
          expect(session.expiration).toBeGreaterThan(mockSession.expiration);
          expect(localStorageMock.get).not.toHaveBeenCalled();
          expect(localStorageMock.set).toHaveBeenCalledTimes(1);
          expect(localStorageMock.set).toHaveBeenCalledWith(
            SESSION_STORAGE_KEY,
            session,
          );
          expect(cookieStorageMock.set).toHaveBeenCalledWith(
            SESSION_ID_STORAGE_KEY,
            session.sessionId,
          );
        });
      });

      describe('when the session is expired', () => {
        beforeEach(() => {
          const tenMinutesAgo = new Date();
          tenMinutesAgo.setMinutes(tenMinutesAgo.getMinutes() - 10);
          mockSession = MockClientSession({
            expiration: tenMinutesAgo.getTime(),
          });
          localStorageMock.get.mockReturnValueOnce(mockSession);
        });

        it('creates a new session and stores it', () => {
          const sessionManager = new SessionManager(TEST_WRITE_KEY);
          const result = sessionManager.getOrCreateSession();

          expect(localStorageMock.get).toHaveBeenCalledWith(
            SESSION_STORAGE_KEY,
          );
          expect(localStorageMock.get).not.toHaveBeenCalledWith(
            LEGACY_SESSION_STORAGE_KEY,
          );
          expect(localStorageMock.set).toHaveBeenCalledTimes(1);
          expect(localStorageMock.set).toHaveBeenCalledWith(
            SESSION_STORAGE_KEY,
            result,
          );
          expect(cookieStorageMock.set).toHaveBeenCalledWith(
            SESSION_ID_STORAGE_KEY,
            result.sessionId,
          );
        });
      });
    });
  });
});