@lkangd/cc-env 1.0.0

package/tests/flows/preset-create-flow.test.ts

@@ -0,0 +1,225 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  advancePresetCreateFlow,
+  createPresetCreateFlowState,
+  type PresetCreateFlowState,
+} from '../../src/flows/preset-create-flow.js'
+
+describe('preset create flow', () => {
+  it("starts at step 'source' with empty defaults", () => {
+    expect(createPresetCreateFlowState()).toEqual({
+      step: 'source',
+      env: {},
+      allKeys: [],
+      selectedKeys: [],
+      presetName: '',
+    })
+  })
+
+  describe('file path', () => {
+    function goToFilePath(): PresetCreateFlowState {
+      return advancePresetCreateFlow(createPresetCreateFlowState(), {
+        type: 'select-source',
+        source: 'file',
+      })
+    }
+
+    it('source=file advances to filePath', () => {
+      expect(goToFilePath().step).toBe('filePath')
+    })
+
+    it('set-file-path advances to keys', () => {
+      const state = advancePresetCreateFlow(goToFilePath(), {
+        type: 'set-file-path',
+        filePath: '/path/to/env.json',
+      })
+      expect(state.step).toBe('keys')
+      expect(state.filePath).toBe('/path/to/env.json')
+    })
+
+    it('set-error stays on filePath with error message', () => {
+      const state = advancePresetCreateFlow(goToFilePath(), {
+        type: 'set-error',
+        error: 'File not found',
+      })
+      expect(state.step).toBe('filePath')
+      expect(state.error).toBe('File not found')
+    })
+  })
+
+  describe('manual input path', () => {
+    function goToManualInput(): PresetCreateFlowState {
+      return advancePresetCreateFlow(createPresetCreateFlowState(), {
+        type: 'select-source',
+        source: 'manual',
+      })
+    }
+
+    it('source=manual advances to manualInput', () => {
+      expect(goToManualInput().step).toBe('manualInput')
+    })
+
+    it('add-manual-pair accumulates pairs', () => {
+      const state = advancePresetCreateFlow(goToManualInput(), {
+        type: 'add-manual-pair',
+        key: 'FOO',
+        value: 'bar',
+      })
+      expect(state.env).toEqual({ FOO: 'bar' })
+      expect(state.selectedKeys).toEqual(['FOO'])
+      expect(state.step).toBe('manualInput')
+    })
+
+    it('add-manual-pair overwrites existing key', () => {
+      const first = advancePresetCreateFlow(goToManualInput(), {
+        type: 'add-manual-pair',
+        key: 'FOO',
+        value: 'bar',
+      })
+      const second = advancePresetCreateFlow(first, {
+        type: 'add-manual-pair',
+        key: 'FOO',
+        value: 'updated',
+      })
+      expect(second.env.FOO).toBe('updated')
+      expect(second.selectedKeys).toEqual(['FOO'])
+    })
+
+    it('set-error on manualInput sets error', () => {
+      const state = advancePresetCreateFlow(goToManualInput(), {
+        type: 'set-error',
+        error: 'Invalid format',
+      })
+      expect(state.error).toBe('Invalid format')
+    })
+
+    it('finish-manual-input advances to name', () => {
+      const state = advancePresetCreateFlow(goToManualInput(), {
+        type: 'finish-manual-input',
+      })
+      expect(state.step).toBe('name')
+    })
+  })
+
+  describe('shared path after source input', () => {
+    function goToNameViaFile(): PresetCreateFlowState {
+      const filePath = advancePresetCreateFlow(createPresetCreateFlowState(), {
+        type: 'select-source',
+        source: 'file',
+      })
+      const keys = advancePresetCreateFlow(filePath, {
+        type: 'set-file-path',
+        filePath: '/env.json',
+      })
+      return advancePresetCreateFlow(keys, {
+        type: 'select-keys',
+        keys: ['API_KEY'],
+        env: { API_KEY: 'secret' },
+      })
+    }
+
+    function goToNameViaManual(): PresetCreateFlowState {
+      const manual = advancePresetCreateFlow(createPresetCreateFlowState(), {
+        type: 'select-source',
+        source: 'manual',
+      })
+      return advancePresetCreateFlow(manual, {
+        type: 'finish-manual-input',
+      })
+    }
+
+    it('set-name advances to destination', () => {
+      const state = advancePresetCreateFlow(goToNameViaFile(), {
+        type: 'set-name',
+        name: 'my-preset',
+      })
+      expect(state.step).toBe('destination')
+      expect(state.presetName).toBe('my-preset')
+    })
+
+    it('select-destination advances to confirm', () => {
+      const name = advancePresetCreateFlow(goToNameViaFile(), {
+        type: 'set-name',
+        name: 'my-preset',
+      })
+      const dest = advancePresetCreateFlow(name, {
+        type: 'select-destination',
+        destination: 'global',
+      })
+      expect(dest.step).toBe('confirm')
+      expect(dest.destination).toBe('global')
+    })
+
+    it('confirm advances to done', () => {
+      const name = advancePresetCreateFlow(goToNameViaFile(), {
+        type: 'set-name',
+        name: 'my-preset',
+      })
+      const dest = advancePresetCreateFlow(name, {
+        type: 'select-destination',
+        destination: 'project',
+      })
+      const done = advancePresetCreateFlow(dest, { type: 'confirm' })
+      expect(done.step).toBe('done')
+    })
+
+    it('manual path reaches done through name→destination→confirm', () => {
+      const name = advancePresetCreateFlow(goToNameViaManual(), {
+        type: 'set-name',
+        name: 'manual-preset',
+      })
+      const dest = advancePresetCreateFlow(name, {
+        type: 'select-destination',
+        destination: 'global',
+      })
+      const done = advancePresetCreateFlow(dest, { type: 'confirm' })
+      expect(done.step).toBe('done')
+      expect(done.presetName).toBe('manual-preset')
+    })
+  })
+
+  it('ignores invalid transitions without mutating state', () => {
+    const state = createPresetCreateFlowState()
+
+    expect(
+      advancePresetCreateFlow(state, {
+        type: 'select-keys',
+        keys: ['FOO'],
+        env: { FOO: 'bar' },
+      }),
+    ).toEqual(state)
+
+    expect(
+      advancePresetCreateFlow(state, {
+        type: 'confirm',
+      }),
+    ).toEqual(state)
+  })
+
+  it('ignores changes after the flow is done', () => {
+    const source = advancePresetCreateFlow(createPresetCreateFlowState(), {
+      type: 'select-source',
+      source: 'manual',
+    })
+    const name = advancePresetCreateFlow(source, {
+      type: 'finish-manual-input',
+    })
+    const dest = advancePresetCreateFlow(name, {
+      type: 'set-name',
+      name: 'test',
+    })
+    const confirm = advancePresetCreateFlow(dest, {
+      type: 'select-destination',
+      destination: 'global',
+    })
+    const done = advancePresetCreateFlow(confirm, { type: 'confirm' })
+
+    expect(
+      advancePresetCreateFlow(done, {
+        type: 'select-source',
+        source: 'file',
+      }),
+    ).toEqual(done)
+  })
+})

package/tests/flows/restore-flow.test.ts

@@ -0,0 +1,157 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  advanceRestoreFlow,
+  createRestoreFlowState,
+} from '../../src/flows/restore-flow.js'
+
+const initRecord = {
+  timestamp: '2026-04-24T00:00:00.000Z',
+  action: 'init' as const,
+  migratedKeys: ['ANTHROPIC_AUTH_TOKEN'],
+  sources: [
+    {
+      file: '/Users/test/.claude/settings.json',
+      backup: {},
+    },
+    {
+      file: '/Users/test/.claude/settings.local.json',
+      backup: {
+        ANTHROPIC_AUTH_TOKEN: 'local-token',
+      },
+    },
+  ],
+  shellWrites: [
+    {
+      shell: 'zsh' as const,
+      filePath: '/Users/test/.zshrc',
+      env: {
+        ANTHROPIC_AUTH_TOKEN: 'local-token',
+      },
+    },
+  ],
+}
+
+const restoreRecord = {
+  timestamp: '2026-04-25T00:00:00.000Z',
+  action: 'restore' as const,
+  targetType: 'preset' as const,
+  targetName: 'openai',
+  backup: {
+    OPENAI_API_KEY: 'sk-123',
+  },
+}
+
+function createConfirmState() {
+  const recordState = createRestoreFlowState([restoreRecord])
+  const targetState = advanceRestoreFlow(recordState, {
+    type: 'select-record',
+    timestamp: restoreRecord.timestamp,
+  })
+
+  return advanceRestoreFlow(targetState, {
+    type: 'select-target',
+    targetType: 'preset',
+    targetName: restoreRecord.targetName,
+  })
+}
+
+describe('restore flow', () => {
+  it('starts on the record step', () => {
+    expect(createRestoreFlowState([restoreRecord])).toEqual({
+      step: 'record',
+      records: [restoreRecord],
+    })
+  })
+
+  it('skips target selection for init history entries', () => {
+    const state = createRestoreFlowState([initRecord])
+
+    expect(
+      advanceRestoreFlow(state, {
+        type: 'select-record',
+        timestamp: initRecord.timestamp,
+      }),
+    ).toEqual({
+      step: 'confirm',
+      records: [initRecord],
+      selectedTimestamp: initRecord.timestamp,
+    })
+  })
+
+  it('moves from record to target for restore history entries', () => {
+    const state = createRestoreFlowState([restoreRecord])
+
+    expect(
+      advanceRestoreFlow(state, {
+        type: 'select-record',
+        timestamp: restoreRecord.timestamp,
+      }),
+    ).toEqual({
+      step: 'target',
+      records: [restoreRecord],
+      selectedTimestamp: restoreRecord.timestamp,
+    })
+  })
+
+  it('keeps the record step unchanged when selecting an unknown timestamp', () => {
+    const state = createRestoreFlowState([restoreRecord])
+
+    expect(
+      advanceRestoreFlow(state, {
+        type: 'select-record',
+        timestamp: '2026-04-26T00:00:00.000Z',
+      }),
+    ).toEqual(state)
+  })
+
+  it('moves through target, confirm, and done after selecting a restore record', () => {
+    const confirmState = createConfirmState()
+
+    expect(confirmState).toEqual({
+      step: 'confirm',
+      records: [restoreRecord],
+      selectedTimestamp: restoreRecord.timestamp,
+      targetType: 'preset',
+      targetName: restoreRecord.targetName,
+    })
+    expect(advanceRestoreFlow(confirmState, { type: 'confirm' })).toEqual({
+      step: 'done',
+      records: [restoreRecord],
+      selectedTimestamp: restoreRecord.timestamp,
+      targetType: 'preset',
+      targetName: restoreRecord.targetName,
+    })
+  })
+
+  it('finishes an init restore after confirm', () => {
+    const confirmState = advanceRestoreFlow(createRestoreFlowState([initRecord]), {
+      type: 'select-record',
+      timestamp: initRecord.timestamp,
+    })
+
+    expect(advanceRestoreFlow(confirmState, { type: 'confirm' })).toEqual({
+      step: 'done',
+      records: [initRecord],
+      selectedTimestamp: initRecord.timestamp,
+    })
+  })
+
+  it('keeps the done step unchanged for any later action', () => {
+    const doneState = advanceRestoreFlow(createConfirmState(), { type: 'confirm' })
+
+    expect(
+      advanceRestoreFlow(doneState, {
+        type: 'select-record',
+        timestamp: restoreRecord.timestamp,
+      }),
+    ).toEqual(doneState)
+    expect(
+      advanceRestoreFlow(doneState, {
+        type: 'select-target',
+        targetType: 'settings',
+      }),
+    ).toEqual(doneState)
+    expect(advanceRestoreFlow(doneState, { type: 'confirm' })).toEqual(doneState)
+  })
+})