@cakemail-org/cakemail-cli 1.5.0 → 2.0.0

package/tests/helpers/pty-runner.ts

@@ -0,0 +1,181 @@
+import { spawn, IPty } from 'node-pty';
+import { join } from 'path';
+import stripAnsi from 'strip-ansi';
+
+export interface PTYOptions {
+  mockServerPort: number;
+  email?: string;
+  password?: string;
+  timeout?: number;
+  enableColors?: boolean;
+  onData?: (data: string) => void;
+  interactive?: boolean;
+}
+
+export interface PTYResult {
+  output: string;
+  cleanOutput: string; // Output with ANSI codes stripped
+  exitCode: number;
+  pty: IPty;
+}
+
+/**
+ * Run CLI command with PTY (real terminal simulation)
+ *
+ * This simulates a REAL user typing commands in a terminal.
+ * Perfect for testing:
+ * - Interactive prompts
+ * - Colors and formatting
+ * - Spinners and progress bars
+ * - Terminal-specific behavior
+ */
+export async function runCLIWithPTY(
+  args: string[],
+  options: PTYOptions
+): Promise<PTYResult> {
+  const cliPath = join(process.cwd(), 'dist', 'cli.js');
+
+  const env: Record<string, string> = {
+    // Inherit other env vars first
+    ...process.env,
+
+    // Point to mock server (override any existing CAKEMAIL_API_BASE)
+    CAKEMAIL_API_BASE: `http://localhost:${options.mockServerPort}`,
+
+    // Credentials (override any existing credentials)
+    CAKEMAIL_EMAIL: options.email || 'test@example.com',
+    CAKEMAIL_PASSWORD: options.password || 'test-password',
+
+    // Use mock access token to bypass OAuth flow
+    CAKEMAIL_ACCESS_TOKEN: 'mock-access-token',
+
+    // Batch mode unless interactive
+    // Note: We explicitly set CAKEMAIL_BATCH_MODE to override NODE_ENV=test
+    CAKEMAIL_BATCH_MODE: options.interactive ? 'false' : 'true',
+
+    // Terminal settings
+    TERM: options.enableColors ? 'xterm-256color' : 'dumb',
+    FORCE_COLOR: options.enableColors ? '1' : '0',
+  };
+
+  const pty = spawn('node', [cliPath, ...args], {
+    name: 'xterm-color',
+    cols: 80,
+    rows: 30,
+    cwd: process.cwd(),
+    env
+  });
+
+  let output = '';
+
+  // Collect output
+  pty.onData((data) => {
+    output += data;
+    options.onData?.(data);
+  });
+
+  // Wait for exit or timeout
+  const exitCode = await new Promise<number>((resolve, reject) => {
+    pty.onExit(({ exitCode }) => {
+      resolve(exitCode);
+    });
+
+    // Timeout
+    const timeout = options.timeout || 10000;
+    setTimeout(() => {
+      pty.kill();
+      reject(new Error(`PTY timeout after ${timeout}ms`));
+    }, timeout);
+  });
+
+  return {
+    output,
+    cleanOutput: stripAnsi(output),
+    exitCode,
+    pty
+  };
+}
+
+/**
+ * Run CLI and expect success (exit code 0)
+ */
+export async function runPTYSuccess(
+  args: string[],
+  options: PTYOptions
+): Promise<PTYResult> {
+  const result = await runCLIWithPTY(args, options);
+
+  if (result.exitCode !== 0) {
+    throw new Error(
+      `CLI command failed with exit code ${result.exitCode}\n` +
+      `Command: cakemail ${args.join(' ')}\n` +
+      `Output:\n${result.cleanOutput}`
+    );
+  }
+
+  return result;
+}
+
+/**
+ * Run CLI and expect failure (exit code !== 0)
+ */
+export async function runPTYFailure(
+  args: string[],
+  options: PTYOptions
+): Promise<PTYResult> {
+  const result = await runCLIWithPTY(args, options);
+
+  if (result.exitCode === 0) {
+    throw new Error(
+      `CLI command succeeded when failure was expected\n` +
+      `Command: cakemail ${args.join(' ')}\n` +
+      `Output:\n${result.cleanOutput}`
+    );
+  }
+
+  return result;
+}
+
+/**
+ * Simulate interactive user input
+ *
+ * @example
+ * ```typescript
+ * const interaction = createInteraction([
+ *   { prompt: 'List name:', response: 'My List\r' },
+ *   { prompt: 'Language:', response: 'en\r' },
+ *   { prompt: 'Confirm?', response: 'y\r' }
+ * ]);
+ *
+ * const result = await runCLIWithPTY(['lists', 'create'], {
+ *   mockServerPort,
+ *   interactive: true,
+ *   onData: interaction.handler
+ * });
+ * ```
+ */
+export function createInteraction(steps: Array<{ prompt: string; response: string }>) {
+  let currentStep = 0;
+  let pty: IPty | null = null;
+
+  return {
+    handler: (data: string) => {
+      if (currentStep >= steps.length) return;
+
+      const step = steps[currentStep];
+      if (data.includes(step.prompt)) {
+        // Wait a bit to simulate real user thinking
+        setTimeout(() => {
+          pty?.write(step.response);
+          currentStep++;
+        }, 100);
+      }
+    },
+
+    setPty: (p: IPty) => {
+      pty = p;
+    },
+
+    isComplete: () => currentStep >= steps.length
+  };
+}

package/tests/integration/campaigns-real-api.test.ts

@@ -0,0 +1,196 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { runCLI, runCLISuccess, parseJSONOutput } from '../helpers/cli-runner';
+import './setup-integration';
+
+/**
+ * REAL API INTEGRATION TESTS
+ *
+ * These tests make actual HTTP requests to the Cakemail API.
+ * They test the full end-to-end flow including:
+ * - Authentication
+ * - Real HTTP requests
+ * - Actual data creation/modification
+ * - Real API responses
+ *
+ * Requirements:
+ * - CAKEMAIL_TEST_EMAIL environment variable
+ * - CAKEMAIL_TEST_PASSWORD environment variable
+ * - Valid Cakemail test account
+ *
+ * Note: These tests are slower than mocked tests but provide
+ * real confidence that the CLI works with the actual API.
+ */
+
+const hasCredentials = () => {
+  // Check for test credentials first, then fall back to regular credentials
+  const hasTestCreds = !!(process.env.CAKEMAIL_TEST_EMAIL && process.env.CAKEMAIL_TEST_PASSWORD);
+  const hasRegularCreds = !!(process.env.CAKEMAIL_EMAIL && process.env.CAKEMAIL_PASSWORD);
+  return hasTestCreds || hasRegularCreds;
+};
+
+describe('campaigns (REAL API)', () => {
+  let testCampaignId: number | null = null;
+  let testListId: number | null = null;
+  let testSenderId: number | null = null;
+
+  beforeAll(async () => {
+    if (!hasCredentials()) {
+      console.warn('⚠️  Skipping integration tests - no credentials provided');
+      return;
+    }
+
+    // Get or create a test list (force JSON output for parsing)
+    const listsResult = await runCLI(['-f', 'json', 'lists', 'list', '--limit', '1']);
+    if (listsResult.exitCode === 0) {
+      const lists = parseJSONOutput(listsResult.stdout);
+      if (lists.data && lists.data.length > 0) {
+        testListId = lists.data[0].id;
+      }
+    }
+
+    // Get or create a test sender (force JSON output for parsing)
+    const sendersResult = await runCLI(['-f', 'json', 'senders', 'list', '--limit', '1']);
+    if (sendersResult.exitCode === 0) {
+      const senders = parseJSONOutput(sendersResult.stdout);
+      if (senders.data && senders.data.length > 0) {
+        testSenderId = senders.data[0].id;
+      }
+    }
+  });
+
+  afterAll(async () => {
+    // Clean up: delete test campaign if it was created
+    if (testCampaignId) {
+      await runCLI(['campaigns', 'delete', testCampaignId.toString(), '--force']);
+    }
+  });
+
+  it.skipIf(!hasCredentials())('should list campaigns from real API', async () => {
+    const result = await runCLISuccess(['-f', 'json', 'campaigns', 'list', '--limit', '5']);
+
+    expect(result.exitCode).toBe(0);
+    const output = parseJSONOutput(result.stdout);
+    expect(output).toHaveProperty('data');
+    expect(Array.isArray(output.data)).toBe(true);
+  });
+
+  it.skipIf(!hasCredentials())('should list campaigns in table format', async () => {
+    const result = await runCLISuccess(['-f', 'table', 'campaigns', 'list', '--limit', '5']);
+
+    expect(result.exitCode).toBe(0);
+    // Table output should contain borders
+    expect(result.stdout).toContain('│');
+  });
+
+  it.skipIf(!hasCredentials())('should support pagination', async () => {
+    const result = await runCLISuccess([
+      '-f', 'json',
+      'campaigns', 'list',
+      '--page', '1',
+      '--limit', '2'
+    ]);
+
+    expect(result.exitCode).toBe(0);
+    const output = parseJSONOutput(result.stdout);
+    expect(output.data.length).toBeLessThanOrEqual(2);
+  });
+
+  it.skipIf(!hasCredentials() || !testListId || !testSenderId)(
+    'should create, update, and delete a campaign',
+    async () => {
+      const campaignName = `Test Campaign ${Date.now()}`;
+
+      // 1. Create campaign
+      const createResult = await runCLISuccess([
+        '-f', 'json',
+        'campaigns', 'create',
+        '--name', campaignName,
+        '--list-id', testListId!.toString(),
+        '--sender-id', testSenderId!.toString(),
+        '--batch'
+      ]);
+
+      expect(createResult.exitCode).toBe(0);
+      expect(createResult.stdout.toLowerCase()).toContain('created');
+
+      // Extract campaign ID from output
+      const lines = createResult.stdout.split('\n');
+      const jsonLine = lines.find(line => line.trim().startsWith('{'));
+      expect(jsonLine).toBeDefined();
+
+      const created = JSON.parse(jsonLine!);
+      testCampaignId = created.id;
+      expect(testCampaignId).toBeDefined();
+      expect(created.name).toBe(campaignName);
+
+      // 2. Get campaign details
+      const getResult = await runCLISuccess(['-f', 'json', 'campaigns', 'get', testCampaignId!.toString()]);
+      const fetched = parseJSONOutput(getResult.stdout);
+      expect(fetched.id).toBe(testCampaignId);
+      expect(fetched.name).toBe(campaignName);
+
+      // 3. Update campaign
+      const updatedName = `Updated Campaign ${Date.now()}`;
+      const updateResult = await runCLISuccess([
+        '-f', 'json',
+        'campaigns', 'update', testCampaignId!.toString(),
+        '--name', updatedName
+      ]);
+
+      expect(updateResult.exitCode).toBe(0);
+      expect(updateResult.stdout.toLowerCase()).toContain('updated');
+
+      // 4. Verify update
+      const getUpdatedResult = await runCLISuccess(['-f', 'json', 'campaigns', 'get', testCampaignId!.toString()]);
+      const updated = parseJSONOutput(getUpdatedResult.stdout);
+      expect(updated.name).toBe(updatedName);
+
+      // 5. Delete campaign
+      const deleteResult = await runCLISuccess([
+        '-f', 'json',
+        'campaigns', 'delete', testCampaignId!.toString(),
+        '--force'
+      ]);
+
+      expect(deleteResult.exitCode).toBe(0);
+      expect(deleteResult.stdout.toLowerCase()).toContain('deleted');
+
+      testCampaignId = null; // Mark as cleaned up
+    },
+    60000 // 60 second timeout for full lifecycle
+  );
+
+  it.skipIf(!hasCredentials())('should handle non-existent campaign gracefully', async () => {
+    const result = await runCLI(['campaigns', 'get', '99999999']);
+
+    expect(result.exitCode).toBe(1);
+    // The API returns a 400 error for non-existent campaigns
+    expect(result.stderr.toLowerCase()).toMatch(/error|400/);
+  });
+
+  it.skipIf(!hasCredentials())('should work with different output profiles', async () => {
+    // Test developer profile
+    const devResult = await runCLISuccess([
+      '--profile', 'developer',
+      'campaigns', 'list',
+      '--limit', '1'
+    ]);
+    expect(devResult.exitCode).toBe(0);
+
+    // Test marketer profile
+    const marketerResult = await runCLISuccess([
+      '--profile', 'marketer',
+      'campaigns', 'list',
+      '--limit', '1'
+    ]);
+    expect(marketerResult.exitCode).toBe(0);
+
+    // Test balanced profile
+    const balancedResult = await runCLISuccess([
+      '--profile', 'balanced',
+      'campaigns', 'list',
+      '--limit', '1'
+    ]);
+    expect(balancedResult.exitCode).toBe(0);
+  });
+});

package/tests/integration/setup-integration.ts

@@ -0,0 +1,50 @@
+import { beforeAll } from 'vitest';
+import { config } from 'dotenv';
+import { resolve } from 'path';
+
+// Load .env file from project root IMMEDIATELY (before test file loads)
+// This ensures credentials are available for it.skipIf() checks
+config({ path: resolve(process.cwd(), '.env') });
+
+// IMPORTANT: Capture real credentials early, before tests/setup.ts overwrites them
+// Integration tests need REAL credentials, not the test defaults
+const envCreds = {
+  email: process.env.CAKEMAIL_EMAIL,
+  password: process.env.CAKEMAIL_PASSWORD
+};
+
+/**
+ * Setup for REAL API integration tests
+ * These tests make actual HTTP calls to the Cakemail API
+ */
+beforeAll(() => {
+  // Restore real credentials (tests/setup.ts sets fake defaults)
+  if (envCreds.email && envCreds.password) {
+    process.env.CAKEMAIL_EMAIL = envCreds.email;
+    process.env.CAKEMAIL_PASSWORD = envCreds.password;
+  }
+
+  // Verify we have real test credentials
+  const hasTestCreds = !!(process.env.CAKEMAIL_TEST_EMAIL && process.env.CAKEMAIL_TEST_PASSWORD);
+  const hasRegularCreds = !!(process.env.CAKEMAIL_EMAIL && process.env.CAKEMAIL_PASSWORD);
+
+  if (!hasTestCreds && !hasRegularCreds) {
+    console.warn('⚠️  Integration tests require credentials:');
+    console.warn('   CAKEMAIL_TEST_EMAIL + CAKEMAIL_TEST_PASSWORD');
+    console.warn('   OR');
+    console.warn('   CAKEMAIL_EMAIL + CAKEMAIL_PASSWORD');
+    console.warn('   These tests will be skipped.');
+  }
+
+  // Use TEST credentials if available, otherwise use regular credentials
+  if (process.env.CAKEMAIL_TEST_EMAIL && process.env.CAKEMAIL_TEST_PASSWORD) {
+    process.env.CAKEMAIL_EMAIL = process.env.CAKEMAIL_TEST_EMAIL;
+    process.env.CAKEMAIL_PASSWORD = process.env.CAKEMAIL_TEST_PASSWORD;
+  }
+  // If no TEST credentials, regular CAKEMAIL_EMAIL/PASSWORD will be used as-is
+
+  // Ensure batch mode for non-interactive testing
+  process.env.CAKEMAIL_BATCH_MODE = 'true';
+
+  // Don't override NODE_ENV to 'test' - the SDK may need it for proper initialization
+});

package/tests/pty/campaigns.test.ts

@@ -0,0 +1,241 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { Server } from 'http';
+import { startMockServer, stopMockServer } from '../helpers/mock-server';
+import { runPTYSuccess, runPTYFailure } from '../helpers/pty-runner';
+
+/**
+ * PTY Tests for Campaigns Command
+ *
+ * These tests simulate a REAL user in a terminal:
+ * - Real terminal (PTY)
+ * - Real HTTP requests to mock server
+ * - Can see colors, spinners, interactive prompts
+ *
+ * Run with: npm install node-pty @types/node-pty
+ */
+describe('campaigns commands (PTY)', () => {
+  let mockServer: Server;
+  let mockPort: number;
+
+  beforeAll(async () => {
+    const server = await startMockServer();
+    mockServer = server.server;
+    mockPort = server.port;
+    console.log(`Mock server started on port ${mockPort}`);
+  });
+
+  afterAll(async () => {
+    await stopMockServer(mockServer);
+  });
+
+  describe('campaigns list', () => {
+    it('should list campaigns like a real user', async () => {
+      const result = await runPTYSuccess(
+        ['campaigns', 'list'],
+        {
+          mockServerPort: mockPort,
+          interactive: true  // Enable spinners
+        }
+      );
+
+      // Check output (can see spinners, colors, etc!)
+      expect(result.exitCode).toBe(0);
+      expect(result.cleanOutput).toContain('Test Campaign 1');
+      expect(result.cleanOutput).toContain('Test Campaign 2');
+
+      // Output should have shown spinner
+      expect(result.output).toMatch(/Fetching campaigns/);
+    });
+
+    it('should list campaigns in JSON format', async () => {
+      const result = await runPTYSuccess(
+        ['-f', 'json', 'campaigns', 'list'],
+        { mockServerPort: mockPort }
+      );
+
+      expect(result.exitCode).toBe(0);
+
+      // Parse JSON output
+      const json = JSON.parse(result.cleanOutput);
+      expect(json.data).toHaveLength(2);
+      expect(json.data[0].name).toBe('Test Campaign 1');
+    });
+
+    it('should list campaigns in table format', async () => {
+      const result = await runPTYSuccess(
+        ['-f', 'table', 'campaigns', 'list'],
+        { mockServerPort: mockPort }
+      );
+
+      expect(result.exitCode).toBe(0);
+      expect(result.cleanOutput).toContain('│'); // Table borders
+      expect(result.cleanOutput).toContain('Test Campaign 1');
+    });
+
+    it('should support pagination', async () => {
+      const result = await runPTYSuccess(
+        ['campaigns', 'list', '--page', '1', '--limit', '10'],
+        { mockServerPort: mockPort }
+      );
+
+      expect(result.exitCode).toBe(0);
+    });
+  });
+
+  describe('campaigns get', () => {
+    it('should get campaign by ID', async () => {
+      const result = await runPTYSuccess(
+        ['-f', 'json', 'campaigns', 'get', '123'],
+        { mockServerPort: mockPort }
+      );
+
+      expect(result.exitCode).toBe(0);
+
+      const json = JSON.parse(result.cleanOutput);
+      expect(json.id).toBe(123);
+      expect(json.name).toBe('Campaign 123');
+    });
+
+    it('should handle campaign not found', async () => {
+      const result = await runPTYFailure(
+        ['campaigns', 'get', '999'],
+        { mockServerPort: mockPort }
+      );
+
+      expect(result.exitCode).toBe(1);
+      expect(result.cleanOutput.toLowerCase()).toMatch(/not found|404|error/);
+    });
+  });
+
+  describe('campaigns create', () => {
+    it('should create campaign', async () => {
+      const result = await runPTYSuccess(
+        [
+          '-f', 'json',
+          'campaigns', 'create',
+          '--name', 'New Campaign',
+          '--list-id', '1',
+          '--sender-id', '1',
+          '--batch'
+        ],
+        { mockServerPort: mockPort }
+      );
+
+      expect(result.exitCode).toBe(0);
+
+      // In batch mode, spinner messages are suppressed, so just parse the JSON output
+      const created = JSON.parse(result.cleanOutput);
+      expect(created.id).toBe(123);
+      expect(created.name).toBe('New Campaign');
+    });
+
+    it('should fail without required fields', async () => {
+      const result = await runPTYFailure(
+        ['campaigns', 'create', '--batch'],
+        { mockServerPort: mockPort }
+      );
+
+      expect(result.exitCode).toBe(1);
+      expect(result.cleanOutput.toLowerCase()).toMatch(/required|missing/);
+    });
+  });
+
+  describe('campaigns update', () => {
+    it('should update campaign name', async () => {
+      const result = await runPTYSuccess(
+        [
+          '-f', 'json',
+          'campaigns', 'update', '123',
+          '--name', 'Updated Campaign'
+        ],
+        { mockServerPort: mockPort }
+      );
+
+      expect(result.exitCode).toBe(0);
+      expect(result.cleanOutput.toLowerCase()).toContain('updated');
+    });
+  });
+
+  describe('campaigns delete', () => {
+    it('should delete campaign with force flag', async () => {
+      const result = await runPTYSuccess(
+        ['campaigns', 'delete', '123', '--force'],
+        { mockServerPort: mockPort }
+      );
+
+      expect(result.exitCode).toBe(0);
+      expect(result.cleanOutput.toLowerCase()).toContain('deleted');
+    });
+  });
+
+  describe('output profiles', () => {
+    it('should work with developer profile', async () => {
+      const result = await runPTYSuccess(
+        ['-f', 'json', '--profile', 'developer', 'campaigns', 'list'],
+        { mockServerPort: mockPort }
+      );
+
+      expect(result.exitCode).toBe(0);
+      // Developer profile defaults to JSON (but we force it here because batch mode changes defaults)
+      expect(() => JSON.parse(result.cleanOutput)).not.toThrow();
+    });
+
+    it('should work with marketer profile', async () => {
+      const result = await runPTYSuccess(
+        ['--profile', 'marketer', 'campaigns', 'list'],
+        { mockServerPort: mockPort }
+      );
+
+      expect(result.exitCode).toBe(0);
+    });
+
+    it('should work with balanced profile', async () => {
+      const result = await runPTYSuccess(
+        ['--profile', 'balanced', 'campaigns', 'list'],
+        { mockServerPort: mockPort }
+      );
+
+      expect(result.exitCode).toBe(0);
+    });
+  });
+
+  describe('terminal features', () => {
+    it('should show colors when enabled', async () => {
+      const result = await runPTYSuccess(
+        ['campaigns', 'list'],
+        {
+          mockServerPort: mockPort,
+          enableColors: true
+        }
+      );
+
+      // Should contain ANSI escape codes
+      expect(result.output).toMatch(/\u001b\[\d+m/);
+    });
+
+    it('should show spinners during loading', async () => {
+      const result = await runPTYSuccess(
+        ['campaigns', 'list'],
+        {
+          mockServerPort: mockPort,
+          interactive: true  // Enable spinners
+        }
+      );
+
+      // Should show "Fetching campaigns..." message
+      expect(result.output).toMatch(/Fetching campaigns/);
+    });
+
+    it('should handle batch mode (no colors/spinners)', async () => {
+      const result = await runPTYSuccess(
+        ['campaigns', 'list'],
+        {
+          mockServerPort: mockPort,
+          enableColors: false
+        }
+      );
+
+      expect(result.exitCode).toBe(0);
+    });
+  });
+});

package/tests/setup.ts

@@ -0,0 +1,34 @@
+import { beforeAll, afterAll } from 'vitest';
+import { mkdirSync, rmSync, existsSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Global test setup
+ *
+ * This runs for all test types:
+ * - PTY tests (use mock HTTP server)
+ * - Integration tests (use real API, override these settings)
+ */
+beforeAll(() => {
+  // Create temporary test config directory
+  const testConfigDir = join(process.cwd(), '.test-config');
+  if (!existsSync(testConfigDir)) {
+    mkdirSync(testConfigDir, { recursive: true });
+  }
+
+  // Set default test environment variables
+  // Note: Integration tests will override these with real credentials
+  process.env.CAKEMAIL_EMAIL = 'test@example.com';
+  process.env.CAKEMAIL_PASSWORD = 'test-password';
+  process.env.CAKEMAIL_BATCH_MODE = 'true'; // Disable interactive prompts
+  process.env.NODE_ENV = 'test';
+});
+
+// Clean up after all tests
+afterAll(() => {
+  // Remove test config directory
+  const testConfigDir = join(process.cwd(), '.test-config');
+  if (existsSync(testConfigDir)) {
+    rmSync(testConfigDir, { recursive: true, force: true });
+  }
+});