resend-cli 1.0.3 → 1.2.0

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

@@ -0,0 +1,137 @@
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  spyOn,
+  test,
+} from 'bun:test';
+import {
+  captureTestEnv,
+  expectExit1,
+  mockExitThrow,
+  mockSdkError,
+  setNonInteractive,
+  setupOutputSpies,
+} from '../../helpers';
+
+const mockGet = mock(async () => ({
+  data: {
+    object: 'segment' as const,
+    id: '3f2a1b4c-5d6e-7f8a-9b0c-1d2e3f4a5b6c',
+    name: 'Newsletter Subscribers',
+    created_at: '2026-01-01T00:00:00.000Z',
+  },
+  error: null,
+}));
+
+mock.module('resend', () => ({
+  Resend: class MockResend {
+    constructor(public key: string) {}
+    segments = { get: mockGet };
+  },
+}));
+
+describe('segments get 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';
+    mockGet.mockClear();
+  });
+
+  afterEach(() => {
+    restoreEnv();
+    spies?.restore();
+    errorSpy?.mockRestore();
+    stderrSpy?.mockRestore();
+    exitSpy?.mockRestore();
+    spies = undefined;
+    errorSpy = undefined;
+    stderrSpy = undefined;
+    exitSpy = undefined;
+  });
+
+  test('calls SDK with the provided segment ID', async () => {
+    spies = setupOutputSpies();
+
+    const { getSegmentCommand } = await import(
+      '../../../src/commands/segments/get'
+    );
+    await getSegmentCommand.parseAsync(
+      ['3f2a1b4c-5d6e-7f8a-9b0c-1d2e3f4a5b6c'],
+      { from: 'user' },
+    );
+
+    expect(mockGet).toHaveBeenCalledTimes(1);
+    expect(mockGet.mock.calls[0][0]).toBe(
+      '3f2a1b4c-5d6e-7f8a-9b0c-1d2e3f4a5b6c',
+    );
+  });
+
+  test('outputs JSON segment data when non-interactive', async () => {
+    spies = setupOutputSpies();
+
+    const { getSegmentCommand } = await import(
+      '../../../src/commands/segments/get'
+    );
+    await getSegmentCommand.parseAsync(
+      ['3f2a1b4c-5d6e-7f8a-9b0c-1d2e3f4a5b6c'],
+      { 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');
+    expect(parsed.created_at).toBe('2026-01-01T00:00:00.000Z');
+  });
+
+  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 { getSegmentCommand } = await import(
+      '../../../src/commands/segments/get'
+    );
+    await expectExit1(() =>
+      getSegmentCommand.parseAsync(['3f2a1b4c-5d6e-7f8a-9b0c-1d2e3f4a5b6c'], {
+        from: 'user',
+      }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('auth_error');
+  });
+
+  test('errors with fetch_error when SDK returns an error', async () => {
+    setNonInteractive();
+    mockGet.mockResolvedValueOnce(
+      mockSdkError('Segment not found', 'not_found'),
+    );
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
+    exitSpy = mockExitThrow();
+
+    const { getSegmentCommand } = await import(
+      '../../../src/commands/segments/get'
+    );
+    await expectExit1(() =>
+      getSegmentCommand.parseAsync(['00000000-0000-0000-0000-000000000000'], {
+        from: 'user',
+      }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('fetch_error');
+  });
+});

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

@@ -0,0 +1,173 @@
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  spyOn,
+  test,
+} from 'bun:test';
+import {
+  captureTestEnv,
+  expectExit1,
+  mockExitThrow,
+  mockSdkError,
+  setNonInteractive,
+  setupOutputSpies,
+} from '../../helpers';
+
+const mockList = mock(async () => ({
+  data: {
+    object: 'list' as const,
+    data: [
+      {
+        id: '3f2a1b4c-5d6e-7f8a-9b0c-1d2e3f4a5b6c',
+        name: 'Newsletter Subscribers',
+        created_at: '2026-01-01T00:00:00.000Z',
+      },
+    ],
+    has_more: false,
+  },
+  error: null,
+}));
+
+mock.module('resend', () => ({
+  Resend: class MockResend {
+    constructor(public key: string) {}
+    segments = { list: mockList };
+  },
+}));
+
+describe('segments list 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';
+    mockList.mockClear();
+  });
+
+  afterEach(() => {
+    restoreEnv();
+    spies?.restore();
+    errorSpy?.mockRestore();
+    stderrSpy?.mockRestore();
+    exitSpy?.mockRestore();
+    spies = undefined;
+    errorSpy = undefined;
+    stderrSpy = undefined;
+    exitSpy = undefined;
+  });
+
+  test('calls SDK with default limit of 10', async () => {
+    spies = setupOutputSpies();
+
+    const { listSegmentsCommand } = await import(
+      '../../../src/commands/segments/list'
+    );
+    await listSegmentsCommand.parseAsync([], { from: 'user' });
+
+    expect(mockList).toHaveBeenCalledTimes(1);
+    const args = mockList.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.limit).toBe(10);
+  });
+
+  test('calls SDK with custom --limit', async () => {
+    spies = setupOutputSpies();
+
+    const { listSegmentsCommand } = await import(
+      '../../../src/commands/segments/list'
+    );
+    await listSegmentsCommand.parseAsync(['--limit', '25'], { from: 'user' });
+
+    const args = mockList.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.limit).toBe(25);
+  });
+
+  test('calls SDK with --after cursor', async () => {
+    spies = setupOutputSpies();
+
+    const { listSegmentsCommand } = await import(
+      '../../../src/commands/segments/list'
+    );
+    await listSegmentsCommand.parseAsync(['--after', 'cursor_xyz'], {
+      from: 'user',
+    });
+
+    const args = mockList.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.after).toBe('cursor_xyz');
+  });
+
+  test('outputs JSON list when non-interactive', async () => {
+    spies = setupOutputSpies();
+
+    const { listSegmentsCommand } = await import(
+      '../../../src/commands/segments/list'
+    );
+    await listSegmentsCommand.parseAsync([], { from: 'user' });
+
+    const output = spies.logSpy.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+    expect(parsed.object).toBe('list');
+    expect(Array.isArray(parsed.data)).toBe(true);
+    expect(parsed.data[0].name).toBe('Newsletter Subscribers');
+    expect(parsed.has_more).toBe(false);
+  });
+
+  test('errors with invalid_limit when --limit is out of range', async () => {
+    setNonInteractive();
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { listSegmentsCommand } = await import(
+      '../../../src/commands/segments/list'
+    );
+    await expectExit1(() =>
+      listSegmentsCommand.parseAsync(['--limit', '0'], { from: 'user' }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('invalid_limit');
+  });
+
+  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 { listSegmentsCommand } = await import(
+      '../../../src/commands/segments/list'
+    );
+    await expectExit1(() =>
+      listSegmentsCommand.parseAsync([], { from: 'user' }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('auth_error');
+  });
+
+  test('errors with list_error when SDK returns an error', async () => {
+    setNonInteractive();
+    mockList.mockResolvedValueOnce(
+      mockSdkError('Server error', 'server_error'),
+    );
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
+    exitSpy = mockExitThrow();
+
+    const { listSegmentsCommand } = await import(
+      '../../../src/commands/segments/list'
+    );
+    await expectExit1(() =>
+      listSegmentsCommand.parseAsync([], { from: 'user' }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('list_error');
+  });
+});

package/tests/commands/teams/list.test.ts

@@ -0,0 +1,63 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+import { mkdirSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { Command } from '@commander-js/extra-typings';
+import { storeApiKey } from '../../../src/lib/config';
+import { captureTestEnv, setupOutputSpies } from '../../helpers';
+
+async function createProgram() {
+  const { listCommand } = await import('../../../src/commands/teams/list');
+  return new Command()
+    .name('resend')
+    .option('--json', 'Force JSON output')
+    .option('--team <name>', 'Team profile')
+    .addCommand(listCommand);
+}
+
+describe('teams list command', () => {
+  const restoreEnv = captureTestEnv();
+  let spies: ReturnType<typeof setupOutputSpies> | 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;
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  test('lists teams in JSON mode', async () => {
+    spies = setupOutputSpies();
+    storeApiKey('re_default', 'default');
+    storeApiKey('re_staging', 'staging');
+
+    const program = await createProgram();
+    await program.parseAsync(['list', '--json'], { from: 'user' });
+
+    const output = JSON.parse(spies.logSpy.mock.calls[0][0] as string);
+    expect(output.teams).toEqual([
+      { name: 'default', active: true },
+      { name: 'staging', active: false },
+    ]);
+  });
+
+  test('shows message when no teams configured', async () => {
+    spies = setupOutputSpies();
+
+    const program = await createProgram();
+    await program.parseAsync(['list'], { from: 'user' });
+
+    const output = spies.logSpy.mock.calls[0][0] as string;
+    expect(output).toContain('No teams configured');
+  });
+});

package/tests/commands/teams/remove.test.ts

@@ -0,0 +1,103 @@
+import { afterEach, beforeEach, describe, expect, spyOn, test } from 'bun:test';
+import { existsSync, mkdirSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { Command } from '@commander-js/extra-typings';
+import { storeApiKey } from '../../../src/lib/config';
+import {
+  captureTestEnv,
+  expectExit1,
+  mockExitThrow,
+  setupOutputSpies,
+} from '../../helpers';
+
+async function createProgram() {
+  const { removeCommand } = await import('../../../src/commands/teams/remove');
+  return new Command()
+    .name('resend')
+    .option('--json', 'Force JSON output')
+    .option('--team <name>', 'Team profile')
+    .addCommand(removeCommand);
+}
+
+describe('teams remove 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 });
+  });
+
+  test('removes team in JSON mode', async () => {
+    spies = setupOutputSpies();
+    storeApiKey('re_default', 'default');
+    storeApiKey('re_staging', 'staging');
+
+    const program = await createProgram();
+    await program.parseAsync(['remove', 'staging', '--json'], { from: 'user' });
+
+    const output = JSON.parse(spies.logSpy.mock.calls[0][0] as string);
+    expect(output.success).toBe(true);
+    expect(output.removed_team).toBe('staging');
+  });
+
+  test('deletes credentials file when last team removed', async () => {
+    spies = setupOutputSpies();
+    storeApiKey('re_only', 'only');
+
+    const program = await createProgram();
+    await program.parseAsync(['remove', 'only', '--json'], { from: 'user' });
+
+    const configPath = join(tmpDir, 'resend', 'credentials.json');
+    expect(existsSync(configPath)).toBe(false);
+  });
+
+  test('errors when name omitted in non-interactive mode', async () => {
+    spies = setupOutputSpies();
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+    storeApiKey('re_default');
+
+    const program = await createProgram();
+    await expectExit1(() =>
+      program.parseAsync(['remove', '--json'], { from: 'user' }),
+    );
+
+    const output = JSON.parse(errorSpy?.mock.calls[0][0] as string);
+    expect(output.error.code).toBe('missing_name');
+  });
+
+  test('errors when team does not exist', async () => {
+    spies = setupOutputSpies();
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+    storeApiKey('re_default');
+
+    const program = await createProgram();
+    await expectExit1(() =>
+      program.parseAsync(['remove', 'nonexistent'], { from: 'user' }),
+    );
+
+    const output = JSON.parse(errorSpy?.mock.calls[0][0] as string);
+    expect(output.error.code).toBe('remove_failed');
+  });
+});

package/tests/commands/teams/switch.test.ts

@@ -0,0 +1,96 @@
+import { afterEach, beforeEach, describe, expect, spyOn, test } from 'bun:test';
+import { mkdirSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { Command } from '@commander-js/extra-typings';
+import { storeApiKey } from '../../../src/lib/config';
+import {
+  captureTestEnv,
+  expectExit1,
+  mockExitThrow,
+  setupOutputSpies,
+} from '../../helpers';
+
+async function createProgram() {
+  const { switchCommand } = await import('../../../src/commands/teams/switch');
+  return new Command()
+    .name('resend')
+    .option('--json', 'Force JSON output')
+    .option('--team <name>', 'Team profile')
+    .addCommand(switchCommand);
+}
+
+describe('teams switch 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 });
+  });
+
+  test('switches active team in JSON mode', async () => {
+    spies = setupOutputSpies();
+    storeApiKey('re_default', 'default');
+    storeApiKey('re_staging', 'staging');
+
+    const program = await createProgram();
+    await program.parseAsync(['switch', 'staging', '--json'], { from: 'user' });
+
+    const output = JSON.parse(spies.logSpy.mock.calls[0][0] as string);
+    expect(output.success).toBe(true);
+    expect(output.active_team).toBe('staging');
+
+    const configPath = join(tmpDir, 'resend', 'credentials.json');
+    const data = JSON.parse(readFileSync(configPath, 'utf-8'));
+    expect(data.active_team).toBe('staging');
+  });
+
+  test('errors when name omitted in non-interactive mode', async () => {
+    spies = setupOutputSpies();
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+    storeApiKey('re_default');
+
+    const program = await createProgram();
+    await expectExit1(() =>
+      program.parseAsync(['switch', '--json'], { from: 'user' }),
+    );
+
+    const output = JSON.parse(errorSpy?.mock.calls[0][0] as string);
+    expect(output.error.code).toBe('missing_name');
+  });
+
+  test('errors when team does not exist', async () => {
+    spies = setupOutputSpies();
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+    storeApiKey('re_default');
+
+    const program = await createProgram();
+    await expectExit1(() =>
+      program.parseAsync(['switch', 'nonexistent'], { from: 'user' }),
+    );
+
+    const output = JSON.parse(errorSpy?.mock.calls[0][0] as string);
+    expect(output.error.code).toBe('switch_failed');
+  });
+});