@lkangd/cc-env 1.1.1 → 1.2.0

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

@@ -1,225 +0,0 @@
-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

@@ -1,157 +0,0 @@
-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)
-  })
-})