resend-cli 1.2.2 → 1.3.0

package/tests/commands/auth/logout.test.ts

@@ -1,146 +0,0 @@
-import { afterEach, beforeEach, describe, expect, spyOn, test } from 'bun:test';
-import { existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import {
-  captureTestEnv,
-  expectExit1,
-  mockExitThrow,
-  setupOutputSpies,
-} from '../../helpers';
-
-describe('logout command', () => {
-  const restoreEnv = captureTestEnv();
-  let spies: ReturnType<typeof setupOutputSpies> | undefined;
-  let errorSpy: ReturnType<typeof spyOn> | undefined;
-  let exitSpy: ReturnType<typeof spyOn> | undefined;
-  let tmpDir: string;
-
-  beforeEach(() => {
-    tmpDir = join(
-      tmpdir(),
-      `resend-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
-    );
-    mkdirSync(tmpDir, { recursive: true });
-    process.env.XDG_CONFIG_HOME = tmpDir;
-  });
-
-  afterEach(() => {
-    restoreEnv();
-    spies?.restore();
-    spies = undefined;
-    errorSpy?.mockRestore();
-    errorSpy = undefined;
-    exitSpy?.mockRestore();
-    exitSpy = undefined;
-    rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  function writeCredentials(
-    teams: Record<string, string> = { default: 're_test_key_123' },
-  ) {
-    const configDir = join(tmpDir, 'resend');
-    mkdirSync(configDir, { recursive: true });
-    const creds = {
-      active_team: Object.keys(teams)[0],
-      teams: Object.fromEntries(
-        Object.entries(teams).map(([name, key]) => [name, { api_key: key }]),
-      ),
-    };
-    writeFileSync(
-      join(configDir, 'credentials.json'),
-      `${JSON.stringify(creds, null, 2)}\n`,
-    );
-  }
-
-  test('removes credentials file when it exists (non-interactive)', async () => {
-    spies = setupOutputSpies();
-    writeCredentials();
-
-    const { logoutCommand } = await import('../../../src/commands/auth/logout');
-    await logoutCommand.parseAsync([], { from: 'user' });
-
-    const configPath = join(tmpDir, 'resend', 'credentials.json');
-    expect(existsSync(configPath)).toBe(false);
-
-    const output = JSON.parse(spies.logSpy.mock.calls[0][0] as string);
-    expect(output.success).toBe(true);
-    expect(output.config_path).toContain('credentials.json');
-  });
-
-  test('exits cleanly when no credentials file exists (non-interactive)', async () => {
-    spies = setupOutputSpies();
-
-    const { logoutCommand } = await import('../../../src/commands/auth/logout');
-    await logoutCommand.parseAsync([], { from: 'user' });
-
-    const output = JSON.parse(spies.logSpy.mock.calls[0][0] as string);
-    expect(output.success).toBe(true);
-    expect(output.already_logged_out).toBe(true);
-  });
-
-  test('logout without --team removes all teams', async () => {
-    spies = setupOutputSpies();
-    writeCredentials({ staging: 're_staging_key', production: 're_prod_key' });
-
-    const { logoutCommand } = await import('../../../src/commands/auth/logout');
-    await logoutCommand.parseAsync([], { from: 'user' });
-
-    const configPath = join(tmpDir, 'resend', 'credentials.json');
-    expect(existsSync(configPath)).toBe(false);
-
-    const output = JSON.parse(spies.logSpy.mock.calls[0][0] as string);
-    expect(output.success).toBe(true);
-    expect(output.team).toBe('all');
-  });
-
-  test('logout with --team removes only that team', async () => {
-    spies = setupOutputSpies();
-    writeCredentials({ staging: 're_staging_key', production: 're_prod_key' });
-
-    // Use the full CLI program so --team global option is recognized
-    const { Command } = await import('@commander-js/extra-typings');
-    const { logoutCommand } = await import('../../../src/commands/auth/logout');
-    const program = new Command()
-      .option('--team <name>')
-      .option('--json')
-      .option('--api-key <key>')
-      .addCommand(logoutCommand);
-
-    await program.parseAsync(['logout', '--team', 'staging'], {
-      from: 'user',
-    });
-
-    const configPath = join(tmpDir, 'resend', 'credentials.json');
-    expect(existsSync(configPath)).toBe(true);
-
-    const remaining = JSON.parse(
-      require('node:fs').readFileSync(configPath, 'utf-8'),
-    );
-    expect(remaining.teams.staging).toBeUndefined();
-    expect(remaining.teams.production).toBeDefined();
-
-    const output = JSON.parse(spies.logSpy.mock.calls[0][0] as string);
-    expect(output.success).toBe(true);
-    expect(output.team).toBe('staging');
-  });
-
-  test('exits with error when file removal fails', async () => {
-    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
-    exitSpy = mockExitThrow();
-    spies = setupOutputSpies();
-    writeCredentials();
-
-    // Make the credentials file a directory so unlinkSync throws
-    const configPath = join(tmpDir, 'resend', 'credentials.json');
-    rmSync(configPath);
-    mkdirSync(configPath); // replace file with a directory — unlinkSync will throw EISDIR
-
-    const { logoutCommand } = await import('../../../src/commands/auth/logout');
-    await expectExit1(() => logoutCommand.parseAsync([], { from: 'user' }));
-
-    expect(errorSpy).toBeDefined();
-    const output = JSON.parse(errorSpy?.mock.calls[0][0] as string);
-    expect(output.error.code).toBe('remove_failed');
-  });
-});

package/tests/commands/broadcasts/create.test.ts

@@ -1,447 +0,0 @@
-import {
-  afterEach,
-  beforeEach,
-  describe,
-  expect,
-  mock,
-  spyOn,
-  test,
-} from 'bun:test';
-import * as files from '../../../src/lib/files';
-import {
-  captureTestEnv,
-  expectExit1,
-  mockExitThrow,
-  mockSdkError,
-  setNonInteractive,
-  setupOutputSpies,
-} from '../../helpers';
-
-const mockCreate = mock(async () => ({
-  data: { id: 'd1c2b3a4-5e6f-7a8b-9c0d-e1f2a3b4c5d6' },
-  error: null,
-}));
-
-mock.module('resend', () => ({
-  Resend: class MockResend {
-    constructor(public key: string) {}
-    broadcasts = { create: mockCreate };
-  },
-}));
-
-describe('broadcasts create command', () => {
-  const restoreEnv = captureTestEnv();
-  let spies: ReturnType<typeof setupOutputSpies> | undefined;
-  let errorSpy: ReturnType<typeof spyOn> | undefined;
-  let stderrSpy: ReturnType<typeof spyOn> | undefined;
-  let exitSpy: ReturnType<typeof spyOn> | undefined;
-  let readFileSpy: ReturnType<typeof spyOn> | undefined;
-
-  beforeEach(() => {
-    process.env.RESEND_API_KEY = 're_test_key';
-    mockCreate.mockClear();
-  });
-
-  afterEach(() => {
-    restoreEnv();
-    spies?.restore();
-    errorSpy?.mockRestore();
-    stderrSpy?.mockRestore();
-    exitSpy?.mockRestore();
-    readFileSpy?.mockRestore();
-    spies = undefined;
-    errorSpy = undefined;
-    stderrSpy = undefined;
-    exitSpy = undefined;
-    readFileSpy = undefined;
-  });
-
-  test('creates broadcast with required flags', async () => {
-    spies = setupOutputSpies();
-
-    const { createBroadcastCommand } = await import(
-      '../../../src/commands/broadcasts/create'
-    );
-    await createBroadcastCommand.parseAsync(
-      [
-        '--from',
-        'hello@domain.com',
-        '--subject',
-        'Weekly Update',
-        '--segment-id',
-        '7b1e0a3d-4c5f-4e8a-9b2d-1a3c5e7f9b2d',
-        '--html',
-        '<p>Hi</p>',
-      ],
-      { from: 'user' },
-    );
-
-    expect(mockCreate).toHaveBeenCalledTimes(1);
-    const args = mockCreate.mock.calls[0][0] as Record<string, unknown>;
-    expect(args.from).toBe('hello@domain.com');
-    expect(args.subject).toBe('Weekly Update');
-    expect(args.segmentId).toBe('7b1e0a3d-4c5f-4e8a-9b2d-1a3c5e7f9b2d');
-    expect(args.html).toBe('<p>Hi</p>');
-  });
-
-  test('outputs JSON id when non-interactive', async () => {
-    spies = setupOutputSpies();
-
-    const { createBroadcastCommand } = await import(
-      '../../../src/commands/broadcasts/create'
-    );
-    await createBroadcastCommand.parseAsync(
-      [
-        '--from',
-        'hello@domain.com',
-        '--subject',
-        'News',
-        '--segment-id',
-        '7b1e0a3d-4c5f-4e8a-9b2d-1a3c5e7f9b2d',
-        '--text',
-        'Hello!',
-      ],
-      { from: 'user' },
-    );
-
-    const output = spies.logSpy.mock.calls[0][0] as string;
-    const parsed = JSON.parse(output);
-    expect(parsed.id).toBe('d1c2b3a4-5e6f-7a8b-9c0d-e1f2a3b4c5d6');
-  });
-
-  test('passes --send flag to SDK', async () => {
-    spies = setupOutputSpies();
-
-    const { createBroadcastCommand } = await import(
-      '../../../src/commands/broadcasts/create'
-    );
-    await createBroadcastCommand.parseAsync(
-      [
-        '--from',
-        'hello@domain.com',
-        '--subject',
-        'Go',
-        '--segment-id',
-        '7b1e0a3d-4c5f-4e8a-9b2d-1a3c5e7f9b2d',
-        '--text',
-        'Hi',
-        '--send',
-      ],
-      { from: 'user' },
-    );
-
-    const args = mockCreate.mock.calls[0][0] as Record<string, unknown>;
-    expect(args.send).toBe(true);
-  });
-
-  test('passes --scheduled-at with --send to SDK', async () => {
-    spies = setupOutputSpies();
-
-    const { createBroadcastCommand } = await import(
-      '../../../src/commands/broadcasts/create'
-    );
-    await createBroadcastCommand.parseAsync(
-      [
-        '--from',
-        'hello@domain.com',
-        '--subject',
-        'Go',
-        '--segment-id',
-        '7b1e0a3d-4c5f-4e8a-9b2d-1a3c5e7f9b2d',
-        '--text',
-        'Hi',
-        '--send',
-        '--scheduled-at',
-        'in 1 hour',
-      ],
-      { from: 'user' },
-    );
-
-    const args = mockCreate.mock.calls[0][0] as Record<string, unknown>;
-    expect(args.scheduledAt).toBe('in 1 hour');
-  });
-
-  test('passes optional flags to SDK', async () => {
-    spies = setupOutputSpies();
-
-    const { createBroadcastCommand } = await import(
-      '../../../src/commands/broadcasts/create'
-    );
-    await createBroadcastCommand.parseAsync(
-      [
-        '--from',
-        'hello@domain.com',
-        '--subject',
-        'News',
-        '--segment-id',
-        '7b1e0a3d-4c5f-4e8a-9b2d-1a3c5e7f9b2d',
-        '--html',
-        '<p>Hi</p>',
-        '--name',
-        'Q1 Newsletter',
-        '--reply-to',
-        'reply@domain.com',
-        '--preview-text',
-        'Read the news',
-        '--topic-id',
-        'topic_xyz',
-      ],
-      { from: 'user' },
-    );
-
-    const args = mockCreate.mock.calls[0][0] as Record<string, unknown>;
-    expect(args.name).toBe('Q1 Newsletter');
-    expect(args.replyTo).toBe('reply@domain.com');
-    expect(args.previewText).toBe('Read the news');
-    expect(args.topicId).toBe('topic_xyz');
-  });
-
-  test('errors with missing_from when --from absent in non-interactive mode', async () => {
-    setNonInteractive();
-    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
-    exitSpy = mockExitThrow();
-
-    const { createBroadcastCommand } = await import(
-      '../../../src/commands/broadcasts/create'
-    );
-    await expectExit1(() =>
-      createBroadcastCommand.parseAsync(
-        [
-          '--subject',
-          'News',
-          '--segment-id',
-          '7b1e0a3d-4c5f-4e8a-9b2d-1a3c5e7f9b2d',
-          '--html',
-          '<p>Hi</p>',
-        ],
-        { from: 'user' },
-      ),
-    );
-
-    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
-    expect(output).toContain('missing_from');
-  });
-
-  test('errors with missing_subject when --subject absent in non-interactive mode', async () => {
-    setNonInteractive();
-    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
-    exitSpy = mockExitThrow();
-
-    const { createBroadcastCommand } = await import(
-      '../../../src/commands/broadcasts/create'
-    );
-    await expectExit1(() =>
-      createBroadcastCommand.parseAsync(
-        [
-          '--from',
-          'hello@domain.com',
-          '--segment-id',
-          '7b1e0a3d-4c5f-4e8a-9b2d-1a3c5e7f9b2d',
-          '--html',
-          '<p>Hi</p>',
-        ],
-        { from: 'user' },
-      ),
-    );
-
-    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
-    expect(output).toContain('missing_subject');
-  });
-
-  test('errors with missing_segment when --segment-id absent in non-interactive mode', async () => {
-    setNonInteractive();
-    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
-    exitSpy = mockExitThrow();
-
-    const { createBroadcastCommand } = await import(
-      '../../../src/commands/broadcasts/create'
-    );
-    await expectExit1(() =>
-      createBroadcastCommand.parseAsync(
-        [
-          '--from',
-          'hello@domain.com',
-          '--subject',
-          'News',
-          '--html',
-          '<p>Hi</p>',
-        ],
-        { from: 'user' },
-      ),
-    );
-
-    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
-    expect(output).toContain('missing_segment');
-  });
-
-  test('errors with missing_body when no body flag in non-interactive mode', async () => {
-    setNonInteractive();
-    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
-    exitSpy = mockExitThrow();
-
-    const { createBroadcastCommand } = await import(
-      '../../../src/commands/broadcasts/create'
-    );
-    await expectExit1(() =>
-      createBroadcastCommand.parseAsync(
-        [
-          '--from',
-          'hello@domain.com',
-          '--subject',
-          'News',
-          '--segment-id',
-          '7b1e0a3d-4c5f-4e8a-9b2d-1a3c5e7f9b2d',
-        ],
-        { from: 'user' },
-      ),
-    );
-
-    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
-    expect(output).toContain('missing_body');
-  });
-
-  test('errors with auth_error when no API key', async () => {
-    setNonInteractive();
-    delete process.env.RESEND_API_KEY;
-    process.env.XDG_CONFIG_HOME = '/tmp/nonexistent-resend';
-    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
-    exitSpy = mockExitThrow();
-
-    const { createBroadcastCommand } = await import(
-      '../../../src/commands/broadcasts/create'
-    );
-    await expectExit1(() =>
-      createBroadcastCommand.parseAsync(
-        [
-          '--from',
-          'hello@domain.com',
-          '--subject',
-          'News',
-          '--segment-id',
-          '7b1e0a3d-4c5f-4e8a-9b2d-1a3c5e7f9b2d',
-          '--html',
-          '<p>Hi</p>',
-        ],
-        { from: 'user' },
-      ),
-    );
-
-    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
-    expect(output).toContain('auth_error');
-  });
-
-  test('errors with create_error when SDK returns an error', async () => {
-    setNonInteractive();
-    mockCreate.mockResolvedValueOnce(
-      mockSdkError('Segment not found', 'not_found'),
-    );
-    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
-    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
-    exitSpy = mockExitThrow();
-
-    const { createBroadcastCommand } = await import(
-      '../../../src/commands/broadcasts/create'
-    );
-    await expectExit1(() =>
-      createBroadcastCommand.parseAsync(
-        [
-          '--from',
-          'hello@domain.com',
-          '--subject',
-          'News',
-          '--segment-id',
-          '00000000-0000-0000-0000-000000000bad',
-          '--html',
-          '<p>Hi</p>',
-        ],
-        { from: 'user' },
-      ),
-    );
-
-    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
-    expect(output).toContain('create_error');
-  });
-
-  test('does not call SDK when validation fails', async () => {
-    setNonInteractive();
-    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
-    exitSpy = mockExitThrow();
-
-    const { createBroadcastCommand } = await import(
-      '../../../src/commands/broadcasts/create'
-    );
-    await expectExit1(() =>
-      createBroadcastCommand.parseAsync([], { from: 'user' }),
-    );
-
-    expect(mockCreate).not.toHaveBeenCalled();
-  });
-
-  test('reads html body from --html-file and passes it to SDK', async () => {
-    spies = setupOutputSpies();
-    readFileSpy = spyOn(files, 'readFile').mockReturnValue('<p>From file</p>');
-
-    const { createBroadcastCommand } = await import(
-      '../../../src/commands/broadcasts/create'
-    );
-    await createBroadcastCommand.parseAsync(
-      [
-        '--from',
-        'hello@domain.com',
-        '--subject',
-        'News',
-        '--segment-id',
-        '7b1e0a3d-4c5f-4e8a-9b2d-1a3c5e7f9b2d',
-        '--html-file',
-        '/fake/email.html',
-      ],
-      { from: 'user' },
-    );
-
-    expect(readFileSpy).toHaveBeenCalledTimes(1);
-    const args = mockCreate.mock.calls[0][0] as Record<string, unknown>;
-    expect(args.html).toBe('<p>From file</p>');
-  });
-
-  test('errors with file_read_error when --html-file path is unreadable', async () => {
-    setNonInteractive();
-    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
-    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
-    exitSpy = mockExitThrow();
-
-    const { outputError } = await import('../../../src/lib/output');
-    readFileSpy = spyOn(files, 'readFile').mockImplementation(
-      (filePath: string, globalOpts: { json?: boolean }) => {
-        outputError(
-          {
-            message: `Failed to read file: ${filePath}`,
-            code: 'file_read_error',
-          },
-          { json: globalOpts.json },
-        );
-      },
-    );
-
-    const { createBroadcastCommand } = await import(
-      '../../../src/commands/broadcasts/create'
-    );
-    await expectExit1(() =>
-      createBroadcastCommand.parseAsync(
-        [
-          '--from',
-          'hello@domain.com',
-          '--subject',
-          'News',
-          '--segment-id',
-          '7b1e0a3d-4c5f-4e8a-9b2d-1a3c5e7f9b2d',
-          '--html-file',
-          '/nonexistent/file.html',
-        ],
-        { from: 'user' },
-      ),
-    );
-
-    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
-    expect(output).toContain('file_read_error');
-  });
-});