resend-cli 1.2.2 → 1.3.1

package/tests/commands/emails/send.test.ts

@@ -1,309 +0,0 @@
-import {
-  afterEach,
-  beforeEach,
-  describe,
-  expect,
-  mock,
-  spyOn,
-  test,
-} from 'bun:test';
-import { unlinkSync } from 'node:fs';
-import { join } from 'node:path';
-import {
-  captureTestEnv,
-  expectExit1,
-  mockExitThrow,
-  setNonInteractive,
-  setupOutputSpies,
-} from '../../helpers';
-
-const mockSend = mock(async () => ({
-  data: { id: 'test-email-id-123' },
-  error: null,
-}));
-
-const mockDomainsList = mock(async () => ({
-  data: { data: [] },
-  error: null,
-}));
-
-mock.module('resend', () => ({
-  Resend: class MockResend {
-    constructor(public key: string) {}
-    emails = { send: mockSend };
-    domains = { list: mockDomainsList };
-  },
-}));
-
-describe('send 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;
-
-  beforeEach(() => {
-    process.env.RESEND_API_KEY = 're_test_key';
-    mockSend.mockClear();
-    mockDomainsList.mockClear();
-  });
-
-  afterEach(() => {
-    restoreEnv();
-    spies?.restore();
-    errorSpy?.mockRestore();
-    stderrSpy?.mockRestore();
-    exitSpy?.mockRestore();
-    spies = undefined;
-    errorSpy = undefined;
-    stderrSpy = undefined;
-    exitSpy = undefined;
-  });
-
-  test('sends email with all flags provided', async () => {
-    spies = setupOutputSpies();
-
-    const { sendCommand } = await import('../../../src/commands/emails/send');
-    await sendCommand.parseAsync(
-      [
-        '--from',
-        'a@test.com',
-        '--to',
-        'b@test.com',
-        '--subject',
-        'Test',
-        '--text',
-        'Hello',
-      ],
-      { from: 'user' },
-    );
-
-    expect(mockSend).toHaveBeenCalledTimes(1);
-    const callArgs = mockSend.mock.calls[0][0] as Record<string, unknown>;
-    expect(callArgs.from).toBe('a@test.com');
-    expect(callArgs.to).toEqual(['b@test.com']);
-    expect(callArgs.subject).toBe('Test');
-    expect(callArgs.text).toBe('Hello');
-  });
-
-  test('outputs JSON with email ID on success', async () => {
-    spies = setupOutputSpies();
-
-    const { sendCommand } = await import('../../../src/commands/emails/send');
-    await sendCommand.parseAsync(
-      [
-        '--from',
-        'a@test.com',
-        '--to',
-        'b@test.com',
-        '--subject',
-        'Test',
-        '--text',
-        'Body',
-      ],
-      { from: 'user' },
-    );
-
-    const output = spies.logSpy.mock.calls[0][0] as string;
-    const parsed = JSON.parse(output);
-    expect(parsed.id).toBe('test-email-id-123');
-  });
-
-  test('sends HTML email when --html provided', async () => {
-    spies = setupOutputSpies();
-
-    const { sendCommand } = await import('../../../src/commands/emails/send');
-    await sendCommand.parseAsync(
-      [
-        '--from',
-        'a@test.com',
-        '--to',
-        'b@test.com',
-        '--subject',
-        'Test',
-        '--html',
-        '<h1>Hello</h1>',
-      ],
-      { from: 'user' },
-    );
-
-    const callArgs = mockSend.mock.calls[0][0] as Record<string, unknown>;
-    expect(callArgs.html).toBe('<h1>Hello</h1>');
-    expect(callArgs.text).toBeUndefined();
-  });
-
-  test('supports multiple --to addresses', async () => {
-    spies = setupOutputSpies();
-
-    const { sendCommand } = await import('../../../src/commands/emails/send');
-    await sendCommand.parseAsync(
-      [
-        '--from',
-        'a@test.com',
-        '--to',
-        'b@test.com',
-        'c@test.com',
-        '--subject',
-        'Test',
-        '--text',
-        'Hi',
-      ],
-      { from: 'user' },
-    );
-
-    const callArgs = mockSend.mock.calls[0][0] as Record<string, unknown>;
-    expect(callArgs.to).toEqual(['b@test.com', 'c@test.com']);
-  });
-
-  test('errors when no API key and non-interactive', async () => {
-    setNonInteractive();
-    delete process.env.RESEND_API_KEY;
-    process.env.XDG_CONFIG_HOME = '/tmp/nonexistent-resend';
-    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
-    exitSpy = mockExitThrow();
-
-    const { sendCommand } = await import('../../../src/commands/emails/send');
-    await expectExit1(() =>
-      sendCommand.parseAsync(
-        [
-          '--from',
-          'a@test.com',
-          '--to',
-          'b@test.com',
-          '--subject',
-          'Test',
-          '--text',
-          'Hi',
-        ],
-        { from: 'user' },
-      ),
-    );
-  });
-
-  test('errors listing missing flags in non-interactive mode', async () => {
-    setNonInteractive();
-    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
-    exitSpy = mockExitThrow();
-
-    const { sendCommand } = await import('../../../src/commands/emails/send');
-    await expectExit1(() =>
-      sendCommand.parseAsync(['--from', 'a@test.com'], { from: 'user' }),
-    );
-
-    const allErrors = errorSpy.mock.calls.map((c) => c[0]).join(' ');
-    expect(allErrors).toContain('--to');
-    expect(allErrors).toContain('--subject');
-  });
-
-  test('errors when no body and non-interactive', async () => {
-    setNonInteractive();
-    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
-    exitSpy = mockExitThrow();
-
-    const { sendCommand } = await import('../../../src/commands/emails/send');
-    await expectExit1(() =>
-      sendCommand.parseAsync(
-        ['--from', 'a@test.com', '--to', 'b@test.com', '--subject', 'Test'],
-        { from: 'user' },
-      ),
-    );
-  });
-
-  test('reads HTML body from --html-file', async () => {
-    spies = setupOutputSpies();
-
-    const tmpFile = join(import.meta.dir, '__test_email.html');
-    await Bun.write(tmpFile, '<h1>From file</h1>');
-
-    try {
-      const { sendCommand } = await import('../../../src/commands/emails/send');
-      await sendCommand.parseAsync(
-        [
-          '--from',
-          'a@test.com',
-          '--to',
-          'b@test.com',
-          '--subject',
-          'Test',
-          '--html-file',
-          tmpFile,
-        ],
-        { from: 'user' },
-      );
-
-      const callArgs = mockSend.mock.calls[0][0] as Record<string, unknown>;
-      expect(callArgs.html).toBe('<h1>From file</h1>');
-    } finally {
-      unlinkSync(tmpFile);
-    }
-  });
-
-  test('passes cc, bcc, reply-to when provided', async () => {
-    spies = setupOutputSpies();
-
-    const { sendCommand } = await import('../../../src/commands/emails/send');
-    await sendCommand.parseAsync(
-      [
-        '--from',
-        'a@test.com',
-        '--to',
-        'b@test.com',
-        '--subject',
-        'Test',
-        '--text',
-        'Body',
-        '--cc',
-        'cc@test.com',
-        '--bcc',
-        'bcc@test.com',
-        '--reply-to',
-        'reply@test.com',
-      ],
-      { from: 'user' },
-    );
-
-    const callArgs = mockSend.mock.calls[0][0] as Record<string, unknown>;
-    expect(callArgs.cc).toEqual(['cc@test.com']);
-    expect(callArgs.bcc).toEqual(['bcc@test.com']);
-    expect(callArgs.replyTo).toBe('reply@test.com');
-  });
-
-  test('does not call domains.list when --from is provided', async () => {
-    spies = setupOutputSpies();
-
-    const { sendCommand } = await import('../../../src/commands/emails/send');
-    await sendCommand.parseAsync(
-      [
-        '--from',
-        'a@test.com',
-        '--to',
-        'b@test.com',
-        '--subject',
-        'Test',
-        '--text',
-        'Hello',
-      ],
-      { from: 'user' },
-    );
-
-    expect(mockDomainsList).not.toHaveBeenCalled();
-    expect(mockSend).toHaveBeenCalledTimes(1);
-  });
-
-  test('degrades gracefully when domain fetch fails', async () => {
-    const { fetchVerifiedDomains } = await import(
-      '../../../src/commands/emails/send'
-    );
-    const failingResend = {
-      domains: {
-        list: mock(async () => {
-          throw new Error('Network error');
-        }),
-      },
-    } as Record<string, unknown>;
-
-    // Should return [] without throwing, so the caller falls through to promptForMissing
-    const result = await fetchVerifiedDomains(failingResend);
-    expect(result).toEqual([]);
-  });
-});

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

@@ -1,163 +0,0 @@
-import {
-  afterEach,
-  beforeEach,
-  describe,
-  expect,
-  mock,
-  spyOn,
-  test,
-} from 'bun:test';
-import {
-  captureTestEnv,
-  expectExit1,
-  mockExitThrow,
-  mockSdkError,
-  setNonInteractive,
-  setupOutputSpies,
-} from '../../helpers';
-
-const mockCreate = mock(async () => ({
-  data: {
-    object: 'segment' as const,
-    id: '3f2a1b4c-5d6e-7f8a-9b0c-1d2e3f4a5b6c',
-    name: 'Newsletter Subscribers',
-  },
-  error: null,
-}));
-
-mock.module('resend', () => ({
-  Resend: class MockResend {
-    constructor(public key: string) {}
-    segments = { create: mockCreate };
-  },
-}));
-
-describe('segments 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;
-
-  beforeEach(() => {
-    process.env.RESEND_API_KEY = 're_test_key';
-    mockCreate.mockClear();
-  });
-
-  afterEach(() => {
-    restoreEnv();
-    spies?.restore();
-    errorSpy?.mockRestore();
-    stderrSpy?.mockRestore();
-    exitSpy?.mockRestore();
-    spies = undefined;
-    errorSpy = undefined;
-    stderrSpy = undefined;
-    exitSpy = undefined;
-  });
-
-  test('creates segment with --name flag', async () => {
-    spies = setupOutputSpies();
-
-    const { createSegmentCommand } = await import(
-      '../../../src/commands/segments/create'
-    );
-    await createSegmentCommand.parseAsync(
-      ['--name', 'Newsletter Subscribers'],
-      { from: 'user' },
-    );
-
-    expect(mockCreate).toHaveBeenCalledTimes(1);
-    const args = mockCreate.mock.calls[0][0] as Record<string, unknown>;
-    expect(args.name).toBe('Newsletter Subscribers');
-  });
-
-  test('outputs JSON with id and object when non-interactive', async () => {
-    spies = setupOutputSpies();
-
-    const { createSegmentCommand } = await import(
-      '../../../src/commands/segments/create'
-    );
-    await createSegmentCommand.parseAsync(
-      ['--name', 'Newsletter Subscribers'],
-      { from: 'user' },
-    );
-
-    const output = spies.logSpy.mock.calls[0][0] as string;
-    const parsed = JSON.parse(output);
-    expect(parsed.object).toBe('segment');
-    expect(parsed.id).toBe('3f2a1b4c-5d6e-7f8a-9b0c-1d2e3f4a5b6c');
-    expect(parsed.name).toBe('Newsletter Subscribers');
-  });
-
-  test('errors with missing_name in non-interactive mode when --name absent', async () => {
-    setNonInteractive();
-    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
-    exitSpy = mockExitThrow();
-
-    const { createSegmentCommand } = await import(
-      '../../../src/commands/segments/create'
-    );
-    await expectExit1(() =>
-      createSegmentCommand.parseAsync([], { from: 'user' }),
-    );
-
-    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
-    expect(output).toContain('missing_name');
-  });
-
-  test('does not call SDK when missing_name error is raised', async () => {
-    setNonInteractive();
-    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
-    exitSpy = mockExitThrow();
-
-    const { createSegmentCommand } = await import(
-      '../../../src/commands/segments/create'
-    );
-    await expectExit1(() =>
-      createSegmentCommand.parseAsync([], { from: 'user' }),
-    );
-
-    expect(mockCreate).not.toHaveBeenCalled();
-  });
-
-  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 { createSegmentCommand } = await import(
-      '../../../src/commands/segments/create'
-    );
-    await expectExit1(() =>
-      createSegmentCommand.parseAsync(['--name', 'Test'], { 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 already exists', 'validation_error'),
-    );
-    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
-    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
-    exitSpy = mockExitThrow();
-
-    const { createSegmentCommand } = await import(
-      '../../../src/commands/segments/create'
-    );
-    await expectExit1(() =>
-      createSegmentCommand.parseAsync(['--name', 'Newsletter Subscribers'], {
-        from: 'user',
-      }),
-    );
-
-    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
-    expect(output).toContain('create_error');
-  });
-});

package/tests/commands/segments/delete.test.ts

@@ -1,182 +0,0 @@
-import {
-  afterEach,
-  beforeEach,
-  describe,
-  expect,
-  mock,
-  spyOn,
-  test,
-} from 'bun:test';
-import {
-  captureTestEnv,
-  expectExit1,
-  mockExitThrow,
-  mockSdkError,
-  setNonInteractive,
-  setupOutputSpies,
-} from '../../helpers';
-
-const mockRemove = mock(async () => ({
-  data: {
-    object: 'segment' as const,
-    id: '3f2a1b4c-5d6e-7f8a-9b0c-1d2e3f4a5b6c',
-    deleted: true,
-  },
-  error: null,
-}));
-
-mock.module('resend', () => ({
-  Resend: class MockResend {
-    constructor(public key: string) {}
-    segments = { remove: mockRemove };
-  },
-}));
-
-describe('segments delete 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;
-
-  beforeEach(() => {
-    process.env.RESEND_API_KEY = 're_test_key';
-    mockRemove.mockClear();
-  });
-
-  afterEach(() => {
-    restoreEnv();
-    spies?.restore();
-    errorSpy?.mockRestore();
-    stderrSpy?.mockRestore();
-    exitSpy?.mockRestore();
-    spies = undefined;
-    errorSpy = undefined;
-    stderrSpy = undefined;
-    exitSpy = undefined;
-  });
-
-  test('deletes segment with --yes flag', async () => {
-    spies = setupOutputSpies();
-
-    const { deleteSegmentCommand } = await import(
-      '../../../src/commands/segments/delete'
-    );
-    await deleteSegmentCommand.parseAsync(
-      ['3f2a1b4c-5d6e-7f8a-9b0c-1d2e3f4a5b6c', '--yes'],
-      {
-        from: 'user',
-      },
-    );
-
-    expect(mockRemove).toHaveBeenCalledTimes(1);
-    expect(mockRemove.mock.calls[0][0]).toBe(
-      '3f2a1b4c-5d6e-7f8a-9b0c-1d2e3f4a5b6c',
-    );
-  });
-
-  test('outputs synthesized JSON result when non-interactive', async () => {
-    spies = setupOutputSpies();
-
-    const { deleteSegmentCommand } = await import(
-      '../../../src/commands/segments/delete'
-    );
-    await deleteSegmentCommand.parseAsync(
-      ['3f2a1b4c-5d6e-7f8a-9b0c-1d2e3f4a5b6c', '--yes'],
-      {
-        from: 'user',
-      },
-    );
-
-    const output = spies.logSpy.mock.calls[0][0] as string;
-    const parsed = JSON.parse(output);
-    expect(parsed.object).toBe('segment');
-    expect(parsed.id).toBe('3f2a1b4c-5d6e-7f8a-9b0c-1d2e3f4a5b6c');
-    expect(parsed.deleted).toBe(true);
-  });
-
-  test('errors with confirmation_required when --yes absent in non-interactive mode', async () => {
-    setNonInteractive();
-    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
-    exitSpy = mockExitThrow();
-
-    const { deleteSegmentCommand } = await import(
-      '../../../src/commands/segments/delete'
-    );
-    await expectExit1(() =>
-      deleteSegmentCommand.parseAsync(
-        ['3f2a1b4c-5d6e-7f8a-9b0c-1d2e3f4a5b6c'],
-        { from: 'user' },
-      ),
-    );
-
-    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
-    expect(output).toContain('confirmation_required');
-  });
-
-  test('does not call SDK when confirmation_required error is raised', async () => {
-    setNonInteractive();
-    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
-    exitSpy = mockExitThrow();
-
-    const { deleteSegmentCommand } = await import(
-      '../../../src/commands/segments/delete'
-    );
-    await expectExit1(() =>
-      deleteSegmentCommand.parseAsync(
-        ['3f2a1b4c-5d6e-7f8a-9b0c-1d2e3f4a5b6c'],
-        { from: 'user' },
-      ),
-    );
-
-    expect(mockRemove).not.toHaveBeenCalled();
-  });
-
-  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 { deleteSegmentCommand } = await import(
-      '../../../src/commands/segments/delete'
-    );
-    await expectExit1(() =>
-      deleteSegmentCommand.parseAsync(
-        ['3f2a1b4c-5d6e-7f8a-9b0c-1d2e3f4a5b6c', '--yes'],
-        {
-          from: 'user',
-        },
-      ),
-    );
-
-    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
-    expect(output).toContain('auth_error');
-  });
-
-  test('errors with delete_error when SDK returns an error', async () => {
-    setNonInteractive();
-    mockRemove.mockResolvedValueOnce(
-      mockSdkError('Segment not found', 'not_found'),
-    );
-    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
-    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
-    exitSpy = mockExitThrow();
-
-    const { deleteSegmentCommand } = await import(
-      '../../../src/commands/segments/delete'
-    );
-    await expectExit1(() =>
-      deleteSegmentCommand.parseAsync(
-        ['00000000-0000-0000-0000-000000000000', '--yes'],
-        {
-          from: 'user',
-        },
-      ),
-    );
-
-    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
-    expect(output).toContain('delete_error');
-  });
-});