state-manager.test.js

const { describe, it, beforeEach } = require('node:test');
const assert = require('node:assert');
const { createStateManager } = require('./state-manager');

function createFakeStorage() {
  const data = new Map();
  return {
    getItem(key) {
      return data.has(key) ? data.get(key) : null;
    },
    setItem(key, value) {
      data.set(key, value);
    },
    removeItem(key) {
      data.delete(key);
    },
    clear() {
      data.clear();
    }
  };
}

describe('state-manager', () => {
  let storage;
  let state;

  beforeEach(() => {
    storage = createFakeStorage();
    state = createStateManager(storage);
  });

  describe('get/set', () => {
    it('returns default value when key is missing', () => {
      assert.strictEqual(state.get('missing', 'default'), 'default');
    });

    it('stores and retrieves a string value', () => {
      state.set('key', 'hello');
      assert.strictEqual(state.get('key'), 'hello');
    });

    it('stores and retrieves an object value', () => {
      state.set('key', { a: 1 });
      assert.deepStrictEqual(state.get('key'), { a: 1 });
    });

    it('stores and retrieves an array value', () => {
      state.set('key', [1, 2, 3]);
      assert.deepStrictEqual(state.get('key'), [1, 2, 3]);
    });

    it('prefixes keys with opencode:', () => {
      state.set('foo', 'bar');
      assert.ok(storage.getItem('opencode:foo'));
    });

    it('returns default when storage contains invalid JSON', () => {
      storage.setItem('opencode:bad', 'not-json{');
      assert.strictEqual(state.get('bad', 'fallback'), 'fallback');
    });

    it('returns default when storage is null', () => {
      const noStorage = createStateManager(null);
      assert.strictEqual(noStorage.get('key', 'default'), 'default');
    });

    it('does not throw when setting with null storage', () => {
      const noStorage = createStateManager(null);
      assert.doesNotThrow(() => noStorage.set('key', 'value'));
    });
  });

  describe('pinned sessions', () => {
    it('returns empty array by default', () => {
      assert.deepStrictEqual(state.getPinnedSessions(), []);
    });

    it('pins a session', () => {
      state.pinSession('s1');
      assert.deepStrictEqual(state.getPinnedSessions(), ['s1']);
    });

    it('pins multiple sessions in order', () => {
      state.pinSession('s1');
      state.pinSession('s2');
      assert.deepStrictEqual(state.getPinnedSessions(), ['s2', 's1']);
    });

    it('does not duplicate pinned sessions', () => {
      state.pinSession('s1');
      state.pinSession('s1');
      assert.deepStrictEqual(state.getPinnedSessions(), ['s1']);
    });

    it('unpins a session', () => {
      state.pinSession('s1');
      state.pinSession('s2');
      state.unpinSession('s1');
      assert.deepStrictEqual(state.getPinnedSessions(), ['s2']);
    });

    it('unpin is idempotent', () => {
      state.unpinSession('nonexistent');
      assert.deepStrictEqual(state.getPinnedSessions(), []);
    });

    it('isPinned returns true for pinned session', () => {
      state.pinSession('s1');
      assert.strictEqual(state.isPinned('s1'), true);
    });

    it('isPinned returns false for unpinned session', () => {
      assert.strictEqual(state.isPinned('s1'), false);
    });

    it('limits pinned sessions to 5', () => {
      state.pinSession('s1');
      state.pinSession('s2');
      state.pinSession('s3');
      state.pinSession('s4');
      state.pinSession('s5');
      state.pinSession('s6');
      assert.strictEqual(state.getPinnedSessions().length, 5);
      assert.deepStrictEqual(state.getPinnedSessions(), ['s6', 's5', 's4', 's3', 's2']);
    });

    it('setPinnedSessions enforces max 5', () => {
      state.setPinnedSessions(['a', 'b', 'c', 'd', 'e', 'f']);
      assert.strictEqual(state.getPinnedSessions().length, 5);
      assert.deepStrictEqual(state.getPinnedSessions(), ['a', 'b', 'c', 'd', 'e']);
    });

    it('ignores non-string entries in stored pinned sessions', () => {
      storage.setItem('opencode:pinnedSessions', JSON.stringify({ _v: 1, value: ['s1', 42, null, 's2'] }));
      assert.deepStrictEqual(state.getPinnedSessions(), ['s1', 's2']);
    });

    it('returns empty array when stored value is not an array', () => {
      storage.setItem('opencode:pinnedSessions', JSON.stringify({ _v: 1, value: 'not-an-array' }));
      assert.deepStrictEqual(state.getPinnedSessions(), []);
    });

    it('persists across state manager instances', () => {
      state.pinSession('s1');
      const state2 = createStateManager(storage);
      assert.deepStrictEqual(state2.getPinnedSessions(), ['s1']);
    });
  });

  describe('group states', () => {
    it('returns empty object by default', () => {
      assert.deepStrictEqual(state.getAllGroupStates(), {});
    });

    it('sets and gets a group collapsed state', () => {
      state.setGroupState('Today', false);
      assert.strictEqual(state.getAllGroupStates().Today, false);
    });

    it('sets multiple group states independently', () => {
      state.setGroupState('Today', true);
      state.setGroupState('Yesterday', false);
      const states = state.getAllGroupStates();
      assert.strictEqual(states.Today, true);
      assert.strictEqual(states.Yesterday, false);
    });

    it('overwrites existing group state', () => {
      state.setGroupState('Today', true);
      state.setGroupState('Today', false);
      assert.strictEqual(state.getAllGroupStates().Today, false);
    });

    it('persists across state manager instances', () => {
      state.setGroupState('Today', false);
      const state2 = createStateManager(storage);
      assert.strictEqual(state2.getAllGroupStates().Today, false);
    });
  });
});