ccs/tests/unit/commands/tokens-command.test.js

/**
 * Tokens Command Tests
 *
 * Tests for the `ccs tokens` CLI command including:
 * - Argument parsing
 * - Token masking
 * - Error handling
 * - Exit codes
 */

const assert = require('assert');

describe('Tokens Command', () => {
  // =========================================================================
  // Token Masking Tests (Unit)
  // =========================================================================
  describe('maskToken', () => {
    // Extract the maskToken function pattern for testing
    function maskToken(token) {
      if (token.length <= 8) return '****';
      return `${token.slice(0, 4)}...${token.slice(-4)}`;
    }

    it('masks tokens showing first 4 and last 4 characters', () => {
      const result = maskToken('1234567890abcdef');
      assert.strictEqual(result, '1234...cdef');
    });

    it('returns **** for tokens <= 8 characters', () => {
      assert.strictEqual(maskToken('12345678'), '****');
      assert.strictEqual(maskToken('1234567'), '****');
      assert.strictEqual(maskToken('abc'), '****');
      assert.strictEqual(maskToken(''), '****');
    });

    it('handles exactly 9 character tokens', () => {
      const result = maskToken('123456789');
      assert.strictEqual(result, '1234...6789');
    });

    it('handles long tokens (typical API keys)', () => {
      const longToken = 'test_key_1234567890abcdefghijklmnopqrstuvwxyz';
      const result = maskToken(longToken);
      assert.strictEqual(result, 'test...wxyz');
    });

    it('preserves special characters in masked output', () => {
      const token = '!@#$abcd____wxyz';
      const result = maskToken(token);
      assert.strictEqual(result, '!@#$...wxyz');
    });
  });

  // =========================================================================
  // Argument Parsing Tests (Unit)
  // =========================================================================
  describe('Argument Parsing', () => {
    /**
     * Simulates the argument parsing logic from tokens-command.ts
     */
    function parseArgs(args) {
      const showFlag = args.includes('--show');
      const resetFlag = args.includes('--reset');
      const regenerateSecretFlag = args.includes('--regenerate-secret');
      const helpFlag = args.includes('--help') || args.includes('-h');

      const apiKeyIndex = args.indexOf('--api-key');
      const apiKeyValue = apiKeyIndex !== -1 ? args[apiKeyIndex + 1] : undefined;

      const secretIndex = args.indexOf('--secret');
      const secretValue = secretIndex !== -1 ? args[secretIndex + 1] : undefined;

      const variantIndex = args.indexOf('--variant');
      const variantValue = variantIndex !== -1 ? args[variantIndex + 1] : undefined;

      return {
        showFlag,
        resetFlag,
        regenerateSecretFlag,
        helpFlag,
        apiKeyValue,
        secretValue,
        variantValue,
      };
    }

    it('parses --show flag', () => {
      const result = parseArgs(['--show']);
      assert.strictEqual(result.showFlag, true);
    });

    it('parses --reset flag', () => {
      const result = parseArgs(['--reset']);
      assert.strictEqual(result.resetFlag, true);
    });

    it('parses --regenerate-secret flag', () => {
      const result = parseArgs(['--regenerate-secret']);
      assert.strictEqual(result.regenerateSecretFlag, true);
    });

    it('parses --help and -h flags', () => {
      assert.strictEqual(parseArgs(['--help']).helpFlag, true);
      assert.strictEqual(parseArgs(['-h']).helpFlag, true);
    });

    it('parses --api-key with value', () => {
      const result = parseArgs(['--api-key', 'my-custom-key']);
      assert.strictEqual(result.apiKeyValue, 'my-custom-key');
    });

    it('parses --secret with value', () => {
      const result = parseArgs(['--secret', 'my-secret']);
      assert.strictEqual(result.secretValue, 'my-secret');
    });

    it('parses --variant with value', () => {
      const result = parseArgs(['--variant', 'gemini']);
      assert.strictEqual(result.variantValue, 'gemini');
    });

    it('parses combined --variant and --api-key', () => {
      const result = parseArgs(['--variant', 'gemini', '--api-key', 'variant-key']);
      assert.strictEqual(result.variantValue, 'gemini');
      assert.strictEqual(result.apiKeyValue, 'variant-key');
    });

    it('handles no arguments (default case)', () => {
      const result = parseArgs([]);
      assert.strictEqual(result.showFlag, false);
      assert.strictEqual(result.resetFlag, false);
      assert.strictEqual(result.apiKeyValue, undefined);
    });

    it('handles multiple flags', () => {
      const result = parseArgs(['--show', '--api-key', 'key', '--variant', 'v1']);
      assert.strictEqual(result.showFlag, true);
      assert.strictEqual(result.apiKeyValue, 'key');
      assert.strictEqual(result.variantValue, 'v1');
    });
  });

  // =========================================================================
  // Validation Tests (Edge Cases)
  // =========================================================================
  describe('Input Validation', () => {
    /**
     * Simulates the validation logic from tokens-command.ts
     */
    function validateApiKeyValue(apiKeyValue) {
      if (apiKeyValue !== undefined) {
        if (!apiKeyValue || apiKeyValue.startsWith('-')) {
          return { valid: false, error: 'Missing value for --api-key' };
        }
      }
      return { valid: true };
    }

    function validateSecretValue(secretValue) {
      if (secretValue !== undefined) {
        if (!secretValue || secretValue.startsWith('-')) {
          return { valid: false, error: 'Missing value for --secret' };
        }
      }
      return { valid: true };
    }

    it('rejects --api-key without value', () => {
      // When --api-key is at end of args, value will be undefined
      const result = validateApiKeyValue(undefined);
      // Note: undefined means flag wasn't provided, empty string means missing value
      assert.strictEqual(result.valid, true); // undefined = not provided = valid
    });

    it('rejects --api-key with empty string', () => {
      const result = validateApiKeyValue('');
      assert.strictEqual(result.valid, false);
      assert.strictEqual(result.error, 'Missing value for --api-key');
    });

    it('rejects --api-key followed by another flag', () => {
      // e.g., --api-key --reset -> apiKeyValue = '--reset'
      const result = validateApiKeyValue('--reset');
      assert.strictEqual(result.valid, false);
      assert.strictEqual(result.error, 'Missing value for --api-key');
    });

    it('rejects --secret with empty string', () => {
      const result = validateSecretValue('');
      assert.strictEqual(result.valid, false);
      assert.strictEqual(result.error, 'Missing value for --secret');
    });

    it('rejects --secret followed by another flag', () => {
      const result = validateSecretValue('--show');
      assert.strictEqual(result.valid, false);
      assert.strictEqual(result.error, 'Missing value for --secret');
    });

    it('accepts valid api key values', () => {
      assert.strictEqual(validateApiKeyValue('my-key').valid, true);
      assert.strictEqual(validateApiKeyValue('sk_live_123').valid, true);
      assert.strictEqual(validateApiKeyValue('a').valid, true);
    });

    it('accepts valid secret values', () => {
      assert.strictEqual(validateSecretValue('my-secret').valid, true);
      assert.strictEqual(validateSecretValue('super-secure-123').valid, true);
    });
  });

  // =========================================================================
  // Exit Code Tests
  // =========================================================================
  describe('Exit Codes', () => {
    it('defines success exit code as 0', () => {
      // These are the expected exit codes from the command
      const EXIT_SUCCESS = 0;
      const EXIT_FAILURE = 1;

      assert.strictEqual(EXIT_SUCCESS, 0);
      assert.strictEqual(EXIT_FAILURE, 1);
    });
  });

  // =========================================================================
  // Help Text Tests
  // =========================================================================
  describe('Help Text Coverage', () => {
    // Verify all documented options are present in help output
    const expectedOptions = [
      '--show',
      '--api-key',
      '--secret',
      '--regenerate-secret',
      '--variant',
      '--reset',
      '--help',
      '-h',
    ];

    it('documents all CLI options', () => {
      // This test ensures we update help when adding new options
      expectedOptions.forEach((option) => {
        assert(typeof option === 'string', `Option ${option} should be a string`);
        assert(option.startsWith('-'), `Option ${option} should start with -`);
      });
    });
  });
});