Skip to content

armgit / Pulse

Public Imported from GitHub
0

Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.

16.6 KB
Raw Blame
import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
import { createRoot } from 'solid-js';
import {
  createLocalStorageBooleanSignal,
  createLocalStorageNumberSignal,
  createLocalStorageStringSignal,
  reserveLowPriorityNoticeSession,
  SESSION_STORAGE_KEYS,
  STORAGE_KEYS,
} from '@/utils/localStorage';

const SYNC_EVENT = 'pulse-localstorage-sync';

// createEffect defers its first run to a microtask; await this after setting up
// or mutating a signal so the sync-to-storage effect has flushed.
const flush = async () => {
  await Promise.resolve();
  await Promise.resolve();
};

type AnySignal<T> = [() => T, (v: T) => void];

const disposables: Array<() => void> = [];

function makeSignal<T>(factory: () => AnySignal<T>): {
  value: () => T;
  setValue: (v: T) => void;
  setValueAny: (v: unknown) => void;
  dispose: () => void;
} {
  let dispose!: () => void;
  let value!: () => T;
  let setValue!: (v: T) => void;
  createRoot((d) => {
    dispose = d;
    [value, setValue] = factory() as AnySignal<T>;
  });
  const disposeFn = () => dispose();
  disposables.push(disposeFn);
  return {
    value: () => value(),
    setValue: (v: T) => setValue(v),
    setValueAny: (v: unknown) => (setValue as (v: unknown) => void)(v),
    dispose: disposeFn,
  };
}

function dispatchCustomSync(key: string, value: string | null) {
  window.dispatchEvent(new CustomEvent(SYNC_EVENT, { detail: { key, value } }));
}

// jsdom's StorageEvent constructor rejects non-jsdom Storage instances for
// storageArea (the shared in-memory storage from setup is a plain class). The
// handler only reads key/newValue/storageArea, so a plain Event with those
// props is sufficient and faithful for exercising the handler logic.
function dispatchStorageEvent(key: string, newValue: string | null, storageArea: Storage | null) {
  const event = new Event('storage');
  Object.defineProperty(event, 'key', { value: key, configurable: true });
  Object.defineProperty(event, 'newValue', { value: newValue, configurable: true });
  Object.defineProperty(event, 'storageArea', { value: storageArea, configurable: true });
  window.dispatchEvent(event);
}

describe('localStorage signals', () => {
  beforeEach(() => {
    localStorage.clear();
    sessionStorage.clear();
  });

  afterEach(() => {
    while (disposables.length) disposables.pop()!();
    vi.restoreAllMocks();
  });

  describe('STORAGE_KEYS', () => {
    it('exposes the expected string keys', () => {
      expect(STORAGE_KEYS.AUTH).toBe('pulse_auth');
      expect(STORAGE_KEYS.AUTH_USER).toBe('pulse_auth_user');
      expect(STORAGE_KEYS.THEME_PREFERENCE).toBe('pulseThemePreference');
      expect(STORAGE_KEYS.SIDEBAR_COLLAPSED).toBe('sidebarCollapsed');
      expect(STORAGE_KEYS.TEMPERATURE_UNIT).toBe('temperatureUnit');
      expect(STORAGE_KEYS.DEBUG_MODE).toBe('pulse_debug_mode');
      expect(STORAGE_KEYS.AUDIT_PAGE_SIZE).toBe('pulse-audit-page-size');
    });

    it('exposes a broad set of keys across feature areas', () => {
      expect(Object.keys(STORAGE_KEYS).length).toBeGreaterThan(40);
      expect(STORAGE_KEYS.WORKLOADS_SEARCH_HISTORY).toBe('workloadsSearchHistory');
      expect(STORAGE_KEYS.GITHUB_STAR_ACTIVE_DAYS).toBe('pulse-github-star-active-days');
      expect(STORAGE_KEYS.GITHUB_STAR_PROMPT_SHOWN).toBe('pulse-github-star-prompt-shown');
    });
  });

  describe('low-priority notice sessions', () => {
    it('allows one owner to reserve and reuse the session notice slot', () => {
      expect(reserveLowPriorityNoticeSession('release-update')).toBe(true);
      expect(reserveLowPriorityNoticeSession('release-update')).toBe(true);
      expect(sessionStorage.getItem(SESSION_STORAGE_KEYS.LOW_PRIORITY_NOTICE_OWNER)).toBe(
        'release-update',
      );
    });

    it('rejects a second low-priority notice owner in the same session', () => {
      expect(reserveLowPriorityNoticeSession('release-update')).toBe(true);
      expect(reserveLowPriorityNoticeSession('github-star')).toBe(false);
    });
  });

  describe('createLocalStorageStringSignal', () => {
    it('uses the default value when storage is empty', async () => {
      const sig = makeSignal(() => createLocalStorageStringSignal('str-key', 'default'));

      expect(sig.value()).toBe('default');
    });

    it('writes the default value to storage once the effect flushes', async () => {
      const sig = makeSignal(() => createLocalStorageStringSignal('str-key', 'default'));
      await flush();

      expect(localStorage.getItem('str-key')).toBe('default');
      sig.dispose();
    });

    it('defaults to an empty string when no default is provided', async () => {
      const sig = makeSignal(() => createLocalStorageStringSignal('str-key'));
      await flush();

      expect(sig.value()).toBe('');
      expect(localStorage.getItem('str-key')).toBe('');
    });

    it('reads a stored value synchronously', () => {
      localStorage.setItem('str-key', 'stored');

      const sig = makeSignal(() => createLocalStorageStringSignal('str-key', 'default'));

      expect(sig.value()).toBe('stored');
    });

    it('writes to localStorage when the value changes', async () => {
      const sig = makeSignal(() => createLocalStorageStringSignal('str-key', 'default'));
      await flush();

      sig.setValue('new-value');
      await flush();

      expect(sig.value()).toBe('new-value');
      expect(localStorage.getItem('str-key')).toBe('new-value');
    });

    it('persists an empty string', async () => {
      const sig = makeSignal(() => createLocalStorageStringSignal('str-key', 'default'));
      await flush();

      sig.setValue('');
      await flush();

      expect(localStorage.getItem('str-key')).toBe('');
    });

    // NOTE: setting null/undefined does NOT persist a removal. The effect removes
    // the item and broadcasts null, but the signal's own same-tab custom-event
    // listener receives that null broadcast and reverts the signal to its
    // defaultValue (applyRaw maps null -> defaultValue). The effect then writes
    // the default back to storage. See GLM_REPORT.md (suspected bug).
    it('reverts to the default when set to null (current behavior)', async () => {
      const sig = makeSignal(() => createLocalStorageStringSignal('str-key', 'default'));
      await flush();
      sig.setValue('changed');
      await flush();
      expect(localStorage.getItem('str-key')).toBe('changed');

      sig.setValueAny(null);
      await flush();

      expect(sig.value()).toBe('default');
      expect(localStorage.getItem('str-key')).toBe('default');
    });

    it('reverts to the default when set to undefined (current behavior)', async () => {
      const sig = makeSignal(() => createLocalStorageStringSignal('str-key', 'default'));
      await flush();
      sig.setValue('changed');
      await flush();
      expect(localStorage.getItem('str-key')).toBe('changed');

      sig.setValueAny(undefined);
      await flush();

      expect(sig.value()).toBe('default');
      expect(localStorage.getItem('str-key')).toBe('default');
    });

    it('broadcasts a sync event when the value changes', async () => {
      const details: Array<{ key: string; value: string | null }> = [];
      const handler = (e: Event) => {
        const evt = e as CustomEvent<{ key: string; value: string | null }>;
        details.push(evt.detail);
      };
      window.addEventListener(SYNC_EVENT, handler);

      const sig = makeSignal(() => createLocalStorageStringSignal('broadcast-key', 'def'));
      await flush();
      expect(details.at(-1)).toEqual({ key: 'broadcast-key', value: 'def' });

      sig.setValue('updated');
      await flush();
      expect(details.at(-1)).toEqual({ key: 'broadcast-key', value: 'updated' });

      sig.setValueAny(null);
      await flush();
      // A null broadcast is emitted (the clear intent), but the same-tab
      // self-sync reverts the signal to its default (suspected bug).
      expect(details).toContainEqual({ key: 'broadcast-key', value: null });
      expect(details.at(-1)).toEqual({ key: 'broadcast-key', value: 'def' });

      window.removeEventListener(SYNC_EVENT, handler);
    });
  });

  describe('createLocalStorageBooleanSignal', () => {
    const parseCases: Array<[string, boolean]> = [
      ['true', true],
      ['false', false],
      ['1', false],
      ['0', false],
      ['TRUE', false],
      ['True', false],
      ['', false],
      ['anything', false],
    ];

    it.each(parseCases)('parses stored %j as %s', (stored, expected) => {
      localStorage.setItem('bool-key', stored);

      const sig = makeSignal(() => createLocalStorageBooleanSignal('bool-key', false));

      expect(sig.value()).toBe(expected);
    });

    it('defaults to false when no default is given and storage is empty', async () => {
      const sig = makeSignal(() => createLocalStorageBooleanSignal('bool-key'));
      await flush();

      expect(sig.value()).toBe(false);
      expect(localStorage.getItem('bool-key')).toBe('false');
    });

    it('defaults to true when provided and storage is empty', async () => {
      const sig = makeSignal(() => createLocalStorageBooleanSignal('bool-key', true));
      await flush();

      expect(sig.value()).toBe(true);
      expect(localStorage.getItem('bool-key')).toBe('true');
    });

    it.each([
      [true, 'true'],
      [false, 'false'],
    ])('writes %s to storage as %j', async (next, expected) => {
      const sig = makeSignal(() => createLocalStorageBooleanSignal('bool-key', false));
      await flush();

      sig.setValue(next);
      await flush();

      expect(localStorage.getItem('bool-key')).toBe(expected);
    });

    it('reverts to the default when set to null (current behavior)', async () => {
      const sig = makeSignal(() => createLocalStorageBooleanSignal('bool-key', true));
      await flush();
      expect(localStorage.getItem('bool-key')).toBe('true');

      sig.setValueAny(null);
      await flush();

      expect(sig.value()).toBe(true);
      expect(localStorage.getItem('bool-key')).toBe('true');
    });
  });

  describe('createLocalStorageNumberSignal', () => {
    const defaultParseCases: Array<[string, number]> = [
      ['42', 42],
      ['3.14', 3.14],
      ['-5', -5],
      ['0', 0],
      ['1e3', 1000],
      ['0x10', 16],
      ['', 0],
      ['  ', 0],
    ];

    it.each(defaultParseCases)('parses stored %j as %s', (stored, expected) => {
      localStorage.setItem('num-key', stored);

      const sig = makeSignal(() => createLocalStorageNumberSignal('num-key', 7));

      expect(sig.value()).toBe(expected);
    });

    it.each([['abc'], ['Infinity'], ['NaN']])(
      'falls back to the default when stored %j is not finite',
      (stored) => {
        localStorage.setItem('num-key', stored);

        const sig = makeSignal(() => createLocalStorageNumberSignal('num-key', 7));

        expect(sig.value()).toBe(7);
      },
    );

    it('heals an invalid stored value by writing the default back to storage', async () => {
      localStorage.setItem('num-key', 'abc');

      const sig = makeSignal(() => createLocalStorageNumberSignal('num-key', 7));
      await flush();

      expect(sig.value()).toBe(7);
      expect(localStorage.getItem('num-key')).toBe('7');
    });

    it('defaults to 0 when no default is given and storage is empty', async () => {
      const sig = makeSignal(() => createLocalStorageNumberSignal('num-key'));
      await flush();

      expect(sig.value()).toBe(0);
      expect(localStorage.getItem('num-key')).toBe('0');
    });

    it.each([
      [99, '99'],
      [0, '0'],
      [-3.5, '-3.5'],
    ])('writes %s to storage as %j', async (next, expected) => {
      const sig = makeSignal(() => createLocalStorageNumberSignal('num-key', 0));
      await flush();

      sig.setValue(next);
      await flush();

      expect(localStorage.getItem('num-key')).toBe(expected);
    });

    it('reverts to the default when set to null (current behavior)', async () => {
      const sig = makeSignal(() => createLocalStorageNumberSignal('num-key', 5));
      await flush();
      expect(localStorage.getItem('num-key')).toBe('5');

      sig.setValueAny(null);
      await flush();

      expect(sig.value()).toBe(5);
      expect(localStorage.getItem('num-key')).toBe('5');
    });
  });

  describe('cross-instance sync', () => {
    it('keeps two signals for the same key in sync', async () => {
      const a = makeSignal(() => createLocalStorageStringSignal('sync-key', 'def'));
      await flush();
      const b = makeSignal(() => createLocalStorageStringSignal('sync-key', 'def'));
      await flush();

      expect(a.value()).toBe('def');
      expect(b.value()).toBe('def');

      a.setValue('from-a');
      await flush();
      expect(b.value()).toBe('from-a');
      expect(localStorage.getItem('sync-key')).toBe('from-a');

      b.setValue('from-b');
      await flush();
      expect(a.value()).toBe('from-b');
    });
  });

  describe('storage event sync', () => {
    it('updates the signal from a storage event for its key', async () => {
      const sig = makeSignal(() => createLocalStorageStringSignal('se-key', 'def'));
      await flush();

      dispatchStorageEvent('se-key', 'from-storage', window.localStorage);

      expect(sig.value()).toBe('from-storage');
    });

    it('ignores storage events for other keys', async () => {
      const sig = makeSignal(() => createLocalStorageStringSignal('se-key', 'def'));
      await flush();

      dispatchStorageEvent('other-key', 'nope', window.localStorage);

      expect(sig.value()).toBe('def');
    });

    it('ignores storage events from a different storage area', async () => {
      const sig = makeSignal(() => createLocalStorageStringSignal('se-key', 'def'));
      await flush();

      dispatchStorageEvent('se-key', 'nope', null);

      expect(sig.value()).toBe('def');
    });

    it('reverts to the default when a storage event clears the key', async () => {
      localStorage.setItem('se-key', 'present');
      const sig = makeSignal(() => createLocalStorageStringSignal('se-key', 'def'));
      await flush();
      expect(sig.value()).toBe('present');

      dispatchStorageEvent('se-key', null, window.localStorage);

      expect(sig.value()).toBe('def');
    });
  });

  describe('custom sync event', () => {
    it('updates the signal from a custom sync event for its key', async () => {
      const sig = makeSignal(() => createLocalStorageStringSignal('cs-key', 'def'));
      await flush();

      dispatchCustomSync('cs-key', 'via-custom');

      expect(sig.value()).toBe('via-custom');
    });

    it('ignores custom sync events for other keys', async () => {
      const sig = makeSignal(() => createLocalStorageStringSignal('cs-key', 'def'));
      await flush();

      dispatchCustomSync('other-key', 'nope');

      expect(sig.value()).toBe('def');
    });

    it('ignores custom sync events without detail', async () => {
      const sig = makeSignal(() => createLocalStorageStringSignal('cs-key', 'def'));
      await flush();

      window.dispatchEvent(new CustomEvent(SYNC_EVENT));

      expect(sig.value()).toBe('def');
    });

    it('reverts to the default when the custom event value is null', async () => {
      localStorage.setItem('cs-key', 'present');
      const sig = makeSignal(() => createLocalStorageStringSignal('cs-key', 'def'));
      await flush();
      expect(sig.value()).toBe('present');

      dispatchCustomSync('cs-key', null);

      expect(sig.value()).toBe('def');
    });

    it('does not change when the custom event carries the current value', async () => {
      const sig = makeSignal(() => createLocalStorageStringSignal('cs-key', 'def'));
      await flush();

      dispatchCustomSync('cs-key', 'def');

      expect(sig.value()).toBe('def');
    });
  });

  describe('cleanup', () => {
    it('stops listening for sync events after disposal', async () => {
      const sig = makeSignal(() => createLocalStorageStringSignal('cu-key', 'def'));
      await flush();
      expect(sig.value()).toBe('def');

      sig.dispose();

      dispatchCustomSync('cu-key', 'after-dispose');
      expect(sig.value()).toBe('def');
    });
  });

  describe('broadcast error handling', () => {
    it('does not throw when dispatching the sync event fails', async () => {
      const dispatchSpy = vi.spyOn(window, 'dispatchEvent').mockImplementation((event: Event) => {
        if (event.type === SYNC_EVENT) {
          throw new Error('dispatch failed');
        }
        return true;
      });

      const sig = makeSignal(() => createLocalStorageStringSignal('err-key', 'def'));
      await flush();
      // setItem runs before the (swallowed) broadcast error
      expect(localStorage.getItem('err-key')).toBe('def');

      sig.setValue('next');
      await flush();
      expect(localStorage.getItem('err-key')).toBe('next');

      dispatchSpy.mockRestore();
    });
  });
});