test(cli): add tests for invalid values

packages/cli/src/index.ts

@@ -5,8 +5,8 @@ import * as path from 'node:path'
 import process from 'node:process'
 import { defineCommand } from 'citty'
 import { consola } from 'consola'
-import { name, version } from '../../toon/package.json' with { type: 'json' }
 import { DEFAULT_DELIMITER, DELIMITERS } from '../../toon/src'
+import { name, version } from '../package.json' with { type: 'json' }
 import { decodeToJson, encodeToToon } from './conversion'
 import { detectMode } from './utils'
 

packages/cli/test/index.test.ts

@@ -1,8 +1,8 @@
 import process from 'node:process'
 import { consola } from 'consola'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { version } from '../../toon/package.json' with { type: 'json' }
 import { DEFAULT_DELIMITER, encode } from '../../toon/src'
+import { version } from '../package.json' with { type: 'json' }
 import { createCliTestContext, runCli } from './utils'
 
 describe('toon CLI', () => {
@@ -14,16 +14,17 @@ describe('toon CLI', () => {
     vi.restoreAllMocks()
   })
 
+  describe('version', () => {
     it('prints the version when using --version', async () => {
       const consolaLog = vi.spyOn(consola, 'log').mockImplementation(() => undefined)
-    const consolaError = vi.spyOn(consola, 'error').mockImplementation(() => undefined)
 
       await runCli({ rawArgs: ['--version'] })
 
       expect(consolaLog).toHaveBeenCalledWith(version)
-    expect(consolaError).not.toHaveBeenCalled()
+    })
   })
 
+  describe('encode (JSON → TOON)', () => {
     it('encodes a JSON file into a TOON file', async () => {
       const data = {
         title: 'TOON test',
@@ -47,38 +48,14 @@ describe('toon CLI', () => {
         })
 
         expect(output).toBe(expected)
-      expect(consolaSuccess).toHaveBeenCalledWith('Encoded `input.json` → `output.toon`')
+        expect(consolaSuccess).toHaveBeenCalledWith(expect.stringMatching(/Encoded .* → .*/))
       }
       finally {
         await context.cleanup()
       }
     })
 
-  it('decodes a TOON file into a JSON file', async () => {
+    it('writes to stdout when output not specified', async () => {
-    const data = {
-      items: ['alpha', 'beta'],
-      meta: { done: false },
-    }
-    const toonInput = encode(data)
-    const context = await createCliTestContext({
-      'input.toon': toonInput,
-    })
-
-    const consolaSuccess = vi.spyOn(consola, 'success').mockImplementation(() => undefined)
-
-    try {
-      await context.run(['input.toon', '--output', 'output.json'])
-
-      const output = await context.read('output.json')
-      expect(JSON.parse(output)).toEqual(data)
-      expect(consolaSuccess).toHaveBeenCalledWith('Decoded `input.toon` → `output.json`')
-    }
-    finally {
-      await context.cleanup()
-    }
-  })
-
-  it('writes encoded TOON to stdout when no output file is provided', async () => {
       const data = { ok: true }
       const context = await createCliTestContext({
         'input.json': JSON.stringify(data),
@@ -100,27 +77,98 @@ describe('toon CLI', () => {
         await context.cleanup()
       }
     })
+  })
 
-  it('throws on an invalid delimiter argument', async () => {
+  describe('decode (TOON → JSON)', () => {
+    it('decodes a TOON file into a JSON file', async () => {
+      const data = {
+        items: ['alpha', 'beta'],
+        meta: { done: false },
+      }
+      const toonInput = encode(data)
+      const context = await createCliTestContext({
+        'input.toon': toonInput,
+      })
+
+      const consolaSuccess = vi.spyOn(consola, 'success').mockImplementation(() => undefined)
+
+      try {
+        await context.run(['input.toon', '--output', 'output.json'])
+
+        const output = await context.read('output.json')
+        expect(JSON.parse(output)).toEqual(data)
+        expect(consolaSuccess).toHaveBeenCalledWith(expect.stringMatching(/Decoded .* → .*/))
+      }
+      finally {
+        await context.cleanup()
+      }
+    })
+  })
+
+  describe('error handling', () => {
+    it('rejects invalid delimiter', async () => {
       const context = await createCliTestContext({
         'input.json': JSON.stringify({ value: 1 }),
       })
 
       const consolaError = vi.spyOn(consola, 'error').mockImplementation(() => undefined)
+      const exitSpy = vi.mocked(process.exit)
 
       try {
-      await expect(context.run(['input.json', '--delimiter', ';'])).resolves.toBeUndefined()
+        await context.run(['input.json', '--delimiter', ';'])
 
-      const exitMock = vi.mocked(process.exit)
+        expect(exitSpy).toHaveBeenCalledWith(1)
-      expect(exitMock).toHaveBeenCalledWith(1)
 
         const errorCall = consolaError.mock.calls.at(0)
         expect(errorCall).toBeDefined()
         const [error] = errorCall!
+        expect(error).toBeInstanceOf(Error)
         expect(error.message).toContain('Invalid delimiter')
       }
       finally {
         await context.cleanup()
       }
     })
+
+    it('rejects invalid indent value', async () => {
+      const context = await createCliTestContext({
+        'input.json': JSON.stringify({ value: 1 }),
+      })
+
+      const consolaError = vi.spyOn(consola, 'error').mockImplementation(() => undefined)
+      const exitSpy = vi.mocked(process.exit)
+
+      try {
+        await context.run(['input.json', '--indent', 'abc'])
+
+        expect(exitSpy).toHaveBeenCalledWith(1)
+
+        const errorCall = consolaError.mock.calls.at(0)
+        expect(errorCall).toBeDefined()
+        const [error] = errorCall!
+        expect(error).toBeInstanceOf(Error)
+        expect(error.message).toContain('Invalid indent value')
+      }
+      finally {
+        await context.cleanup()
+      }
+    })
+
+    it('handles missing input file', async () => {
+      const context = await createCliTestContext({})
+
+      const consolaError = vi.spyOn(consola, 'error').mockImplementation(() => undefined)
+      const exitSpy = vi.mocked(process.exit)
+
+      try {
+        await context.run(['nonexistent.json'])
+
+        expect(exitSpy).toHaveBeenCalledWith(1)
+        expect(consolaError).toHaveBeenCalled()
+      }
+      finally {
+        await context.cleanup()
+      }
+    })
+  })
 })