Skip to content

Beautiful, AI-native markdown IDE and LLM wiki

8.7 KB
Raw Blame
import { describe, expect, test } from 'vitest';
import {
  countUserDocuments,
  createFeedbackNudgeStore,
  DEFAULT_FEEDBACK_NUDGE_STATE,
  FEEDBACK_NUDGE_MIN_AGE_MS,
  FEEDBACK_NUDGE_MIN_DOCS,
  FEEDBACK_NUDGE_STORAGE_KEY,
  type FeedbackNudgeState,
  type FeedbackNudgeStorage,
  isFeedbackNudgeEligible,
  readPersistedState,
  writePersistedState,
} from './feedback-nudge-store.ts';

function memoryStorage(initial: Record<string, string> = {}): FeedbackNudgeStorage & {
  raw(): string | null;
} {
  const data = new Map(Object.entries(initial));
  return {
    getItem(key) {
      return data.get(key) ?? null;
    },
    setItem(key, value) {
      data.set(key, value);
    },
    raw() {
      return data.get(FEEDBACK_NUDGE_STORAGE_KEY) ?? null;
    },
  };
}

function stateWith(overrides: Partial<FeedbackNudgeState>): FeedbackNudgeState {
  return { ...DEFAULT_FEEDBACK_NUDGE_STATE, ...overrides };
}

const NOW = 1_800_000_000_000;
const RIPE = NOW - FEEDBACK_NUDGE_MIN_AGE_MS;

describe('readPersistedState', () => {
  test('absent key returns default', () => {
    expect(readPersistedState(memoryStorage())).toEqual(DEFAULT_FEEDBACK_NUDGE_STATE);
  });

  test('round-trips the durable fields', () => {
    const stored = { firstSeenAt: RIPE, shownAt: NOW, dismissed: true };
    const s = memoryStorage({ [FEEDBACK_NUDGE_STORAGE_KEY]: JSON.stringify(stored) });
    expect(readPersistedState(s)).toEqual(stored);
  });

  test('non-number timestamps and non-boolean flags coerce safely', () => {
    const s = memoryStorage({
      [FEEDBACK_NUDGE_STORAGE_KEY]: JSON.stringify({
        firstSeenAt: '1800000000000',
        shownAt: {},
        dismissed: 1,
      }),
    });
    expect(readPersistedState(s)).toEqual(DEFAULT_FEEDBACK_NUDGE_STATE);
  });

  test('non-positive and non-finite timestamps coerce to null, not to the epoch', () => {
    for (const bad of [0, -1, Number.NaN, Number.POSITIVE_INFINITY]) {
      const s = memoryStorage({
        [FEEDBACK_NUDGE_STORAGE_KEY]: JSON.stringify({ firstSeenAt: bad }),
      });
      expect(readPersistedState(s).firstSeenAt).toBeNull();
    }
  });

  test('corrupt JSON falls back to default', () => {
    const s = memoryStorage({ [FEEDBACK_NUDGE_STORAGE_KEY]: '{not valid json' });
    expect(readPersistedState(s)).toEqual(DEFAULT_FEEDBACK_NUDGE_STATE);
  });
});

describe('writePersistedState', () => {
  test('persists the state verbatim', () => {
    const s = memoryStorage();
    writePersistedState({ firstSeenAt: RIPE, shownAt: null, dismissed: true }, s);
    expect(JSON.parse(s.raw() as string)).toEqual({
      firstSeenAt: RIPE,
      shownAt: null,
      dismissed: true,
    });
  });
});

describe('storage that refuses to write', () => {
  function throwingStorage(): FeedbackNudgeStorage {
    return {
      getItem: () => null,
      setItem: () => {
        throw new DOMException('QuotaExceededError');
      },
    };
  }

  test('writePersistedState does not propagate the failure', () => {
    expect(() =>
      writePersistedState(DEFAULT_FEEDBACK_NUDGE_STATE, throwingStorage()),
    ).not.toThrow();
  });

  test('the store still records the answer in memory for this session', () => {
    const store = createFeedbackNudgeStore(throwingStorage());

    expect(() => store.dismiss()).not.toThrow();
    expect(store.getSnapshot().dismissed).toBe(true);
    expect(isFeedbackNudgeEligible(store.getSnapshot(), NOW, 400)).toBe(false);
  });
});

describe('countUserDocuments', () => {
  test('counts ordinary docs at any depth', () => {
    expect(countUserDocuments(new Set(['notes', 'brain/ideas', 'a/b/c/deep']))).toBe(3);
  });

  test('excludes the .ok substrate that /api/pages serves alongside real docs', () => {
    const pages = new Set([
      'notes',
      '.ok/skills/project/SKILL',
      '.ok/skills/project/references/linking',
      'brain/.ok/templates/article',
      'brain/.ok/frontmatter',
    ]);
    expect(countUserDocuments(pages)).toBe(1);
  });

  test('case-insensitive on the .ok segment, matching the file-tree predicate', () => {
    expect(countUserDocuments(new Set(['.OK/skills/project/SKILL', 'notes']))).toBe(1);
  });

  test('a doc merely named "ok" is not substrate', () => {
    expect(countUserDocuments(new Set(['ok', 'ok/notes', 'notes.ok']))).toBe(3);
  });

  test('empty set counts zero', () => {
    expect(countUserDocuments(new Set())).toBe(0);
  });
});

describe('isFeedbackNudgeEligible', () => {
  test('eligible once both gates pass', () => {
    expect(
      isFeedbackNudgeEligible(stateWith({ firstSeenAt: RIPE }), NOW, FEEDBACK_NUDGE_MIN_DOCS),
    ).toBe(true);
  });

  test('the default state is never eligible — firstSeenAt has not been stamped', () => {
    expect(isFeedbackNudgeEligible(DEFAULT_FEEDBACK_NUDGE_STATE, NOW, 1000)).toBe(false);
  });

  test('not eligible one millisecond before the two-week boundary', () => {
    expect(
      isFeedbackNudgeEligible(stateWith({ firstSeenAt: RIPE + 1 }), NOW, FEEDBACK_NUDGE_MIN_DOCS),
    ).toBe(false);
  });

  test('not eligible one document below the threshold', () => {
    expect(
      isFeedbackNudgeEligible(stateWith({ firstSeenAt: RIPE }), NOW, FEEDBACK_NUDGE_MIN_DOCS - 1),
    ).toBe(false);
  });

  test('a comfortably old, well-populated workspace is eligible', () => {
    expect(isFeedbackNudgeEligible(stateWith({ firstSeenAt: RIPE - 5_000 }), NOW, 400)).toBe(true);
  });

  test('never eligible once shown, regardless of how ripe the gates are', () => {
    expect(
      isFeedbackNudgeEligible(stateWith({ firstSeenAt: RIPE, shownAt: NOW - 1 }), NOW, 400),
    ).toBe(false);
  });

  test('never eligible once dismissed', () => {
    expect(
      isFeedbackNudgeEligible(stateWith({ firstSeenAt: RIPE, dismissed: true }), NOW, 400),
    ).toBe(false);
  });
});

describe('createFeedbackNudgeStore', () => {
  test('recordFirstSeen stamps once and never moves', () => {
    const s = memoryStorage();
    const store = createFeedbackNudgeStore(s);
    store.recordFirstSeen(NOW);
    store.recordFirstSeen(NOW + 90_000);
    expect(store.getSnapshot().firstSeenAt).toBe(NOW);
    expect(JSON.parse(s.raw() as string).firstSeenAt).toBe(NOW);
  });

  test('recordShown latches once', () => {
    const store = createFeedbackNudgeStore(memoryStorage());
    store.recordShown(NOW);
    store.recordShown(NOW + 90_000);
    expect(store.getSnapshot().shownAt).toBe(NOW);
  });

  test('dismiss latches and is idempotent', () => {
    const store = createFeedbackNudgeStore(memoryStorage());
    store.dismiss();
    store.dismiss();
    expect(store.getSnapshot().dismissed).toBe(true);
  });

  test('a fresh store over the same storage keeps the clock and stays suppressed', () => {
    const s = memoryStorage();
    const first = createFeedbackNudgeStore(s);
    first.recordFirstSeen(RIPE);
    first.recordShown(NOW);

    const second = createFeedbackNudgeStore(s);
    expect(second.getSnapshot().firstSeenAt).toBe(RIPE);
    expect(isFeedbackNudgeEligible(second.getSnapshot(), NOW, 400)).toBe(false);
  });

  test('subscribe notifies listeners on real transitions only', () => {
    const store = createFeedbackNudgeStore(memoryStorage());
    let calls = 0;
    const unsub = store.subscribe(() => {
      calls++;
    });
    store.recordFirstSeen(NOW);
    store.recordFirstSeen(NOW);
    unsub();
    store.dismiss();
    expect(calls).toBe(1);
  });

  test('install re-reads storage written after construction', () => {
    const s = memoryStorage();
    const store = createFeedbackNudgeStore(s);
    expect(store.getSnapshot().firstSeenAt).toBeNull();
    writePersistedState(stateWith({ firstSeenAt: RIPE }), s);
    store.install();
    expect(store.getSnapshot().firstSeenAt).toBe(RIPE);
  });

  test('syncFromStorage adopts another window write and notifies', () => {
    const shared = memoryStorage();
    const thisWindow = createFeedbackNudgeStore(shared);
    let notified = 0;
    thisWindow.subscribe(() => {
      notified++;
    });
    expect(thisWindow.getSnapshot().dismissed).toBe(false);

    const otherWindow = createFeedbackNudgeStore(shared);
    otherWindow.dismiss();

    thisWindow.syncFromStorage();
    expect(thisWindow.getSnapshot().dismissed).toBe(true);
    expect(notified).toBeGreaterThan(0);
  });
});

describe('feedback state saved by earlier releases', () => {
  test('the storage key is still ok-feedback-nudge-v1', () => {
    expect(FEEDBACK_NUDGE_STORAGE_KEY).toBe('ok-feedback-nudge-v1');
  });

  test('a prompt already shown and dismissed reads back unchanged and stays ineligible', () => {
    const stored = { firstSeenAt: 1_790_000_000_000, shownAt: 1_791_500_000_000, dismissed: true };
    const s = memoryStorage({ 'ok-feedback-nudge-v1': JSON.stringify(stored) });
    const read = readPersistedState(s);
    expect(read).toEqual(stored);
    expect(isFeedbackNudgeEligible(read, NOW, 400)).toBe(false);
  });
});