resend-cli 1.0.2 → 1.1.0

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

@@ -0,0 +1,283 @@
+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 mockUpdate = mock(async () => ({
+  data: { id: 'd1c2b3a4-5e6f-7a8b-9c0d-e1f2a3b4c5d6' },
+  error: null,
+}));
+
+mock.module('resend', () => ({
+  Resend: class MockResend {
+    constructor(public key: string) {}
+    broadcasts = { update: mockUpdate };
+  },
+}));
+
+describe('broadcasts update 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';
+    mockUpdate.mockClear();
+  });
+
+  afterEach(() => {
+    restoreEnv();
+    spies?.restore();
+    errorSpy?.mockRestore();
+    stderrSpy?.mockRestore();
+    exitSpy?.mockRestore();
+    readFileSpy?.mockRestore();
+    spies = undefined;
+    errorSpy = undefined;
+    stderrSpy = undefined;
+    exitSpy = undefined;
+    readFileSpy = undefined;
+  });
+
+  test('updates broadcast subject', async () => {
+    spies = setupOutputSpies();
+
+    const { updateBroadcastCommand } = await import(
+      '../../../src/commands/broadcasts/update'
+    );
+    await updateBroadcastCommand.parseAsync(
+      ['d1c2b3a4-5e6f-7a8b-9c0d-e1f2a3b4c5d6', '--subject', 'Updated Subject'],
+      { from: 'user' },
+    );
+
+    expect(mockUpdate).toHaveBeenCalledTimes(1);
+    expect(mockUpdate.mock.calls[0][0]).toBe(
+      'd1c2b3a4-5e6f-7a8b-9c0d-e1f2a3b4c5d6',
+    );
+    const payload = mockUpdate.mock.calls[0][1] as Record<string, unknown>;
+    expect(payload.subject).toBe('Updated Subject');
+  });
+
+  test('passes all update flags to SDK', async () => {
+    spies = setupOutputSpies();
+
+    const { updateBroadcastCommand } = await import(
+      '../../../src/commands/broadcasts/update'
+    );
+    await updateBroadcastCommand.parseAsync(
+      [
+        'd1c2b3a4-5e6f-7a8b-9c0d-e1f2a3b4c5d6',
+        '--from',
+        'new@domain.com',
+        '--subject',
+        'New Subject',
+        '--text',
+        'New body',
+        '--name',
+        'New Label',
+      ],
+      { from: 'user' },
+    );
+
+    const payload = mockUpdate.mock.calls[0][1] as Record<string, unknown>;
+    expect(payload.from).toBe('new@domain.com');
+    expect(payload.subject).toBe('New Subject');
+    expect(payload.text).toBe('New body');
+    expect(payload.name).toBe('New Label');
+  });
+
+  test('outputs JSON id when non-interactive', async () => {
+    spies = setupOutputSpies();
+
+    const { updateBroadcastCommand } = await import(
+      '../../../src/commands/broadcasts/update'
+    );
+    await updateBroadcastCommand.parseAsync(
+      ['d1c2b3a4-5e6f-7a8b-9c0d-e1f2a3b4c5d6', '--subject', 'Updated'],
+      { 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('omits undefined fields from SDK payload', async () => {
+    spies = setupOutputSpies();
+
+    const { updateBroadcastCommand } = await import(
+      '../../../src/commands/broadcasts/update'
+    );
+    await updateBroadcastCommand.parseAsync(
+      ['d1c2b3a4-5e6f-7a8b-9c0d-e1f2a3b4c5d6', '--name', 'Only Name'],
+      { from: 'user' },
+    );
+
+    const payload = mockUpdate.mock.calls[0][1] as Record<string, unknown>;
+    expect(payload.name).toBe('Only Name');
+    expect(payload.from).toBeUndefined();
+    expect(payload.subject).toBeUndefined();
+  });
+
+  test('errors with no_changes when no flags are provided', async () => {
+    setNonInteractive();
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { updateBroadcastCommand } = await import(
+      '../../../src/commands/broadcasts/update'
+    );
+    await expectExit1(() =>
+      updateBroadcastCommand.parseAsync(
+        ['d1c2b3a4-5e6f-7a8b-9c0d-e1f2a3b4c5d6'],
+        { from: 'user' },
+      ),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('no_changes');
+  });
+
+  test('does not call SDK when no_changes error is raised', async () => {
+    setNonInteractive();
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { updateBroadcastCommand } = await import(
+      '../../../src/commands/broadcasts/update'
+    );
+    await expectExit1(() =>
+      updateBroadcastCommand.parseAsync(
+        ['d1c2b3a4-5e6f-7a8b-9c0d-e1f2a3b4c5d6'],
+        { from: 'user' },
+      ),
+    );
+
+    expect(mockUpdate).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 { updateBroadcastCommand } = await import(
+      '../../../src/commands/broadcasts/update'
+    );
+    await expectExit1(() =>
+      updateBroadcastCommand.parseAsync(
+        ['d1c2b3a4-5e6f-7a8b-9c0d-e1f2a3b4c5d6', '--subject', 'X'],
+        {
+          from: 'user',
+        },
+      ),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('auth_error');
+  });
+
+  test('errors with update_error when SDK returns an error', async () => {
+    setNonInteractive();
+    mockUpdate.mockResolvedValueOnce(
+      mockSdkError('Cannot update sent broadcast', 'validation_error'),
+    );
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
+    exitSpy = mockExitThrow();
+
+    const { updateBroadcastCommand } = await import(
+      '../../../src/commands/broadcasts/update'
+    );
+    await expectExit1(() =>
+      updateBroadcastCommand.parseAsync(
+        ['s1e2n3t4-5a6b-7c8d-9e0f-a1b2c3d4e5f6', '--subject', 'New'],
+        {
+          from: 'user',
+        },
+      ),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('update_error');
+  });
+
+  test('reads html body from --html-file and passes it to SDK', async () => {
+    spies = setupOutputSpies();
+    readFileSpy = spyOn(files, 'readFile').mockReturnValue(
+      '<p>Updated from file</p>',
+    );
+
+    const { updateBroadcastCommand } = await import(
+      '../../../src/commands/broadcasts/update'
+    );
+    await updateBroadcastCommand.parseAsync(
+      [
+        'd1c2b3a4-5e6f-7a8b-9c0d-e1f2a3b4c5d6',
+        '--html-file',
+        '/fake/email.html',
+      ],
+      { from: 'user' },
+    );
+
+    expect(readFileSpy).toHaveBeenCalledTimes(1);
+    const payload = mockUpdate.mock.calls[0][1] as Record<string, unknown>;
+    expect(payload.html).toBe('<p>Updated 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 { updateBroadcastCommand } = await import(
+      '../../../src/commands/broadcasts/update'
+    );
+    await expectExit1(() =>
+      updateBroadcastCommand.parseAsync(
+        [
+          'd1c2b3a4-5e6f-7a8b-9c0d-e1f2a3b4c5d6',
+          '--html-file',
+          '/nonexistent/file.html',
+        ],
+        { from: 'user' },
+      ),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('file_read_error');
+  });
+});

package/tests/commands/contact-properties/create.test.ts

@@ -0,0 +1,250 @@
+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: 'contact_property' as const,
+    id: 'b4a3c2d1-6e5f-8a7b-0c9d-2e1f4a3b6c5d',
+  },
+  error: null,
+}));
+
+mock.module('resend', () => ({
+  Resend: class MockResend {
+    constructor(public key: string) {}
+    contactProperties = { create: mockCreate };
+  },
+}));
+
+describe('contact-properties 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 property with --key and --type', async () => {
+    spies = setupOutputSpies();
+
+    const { createContactPropertyCommand } = await import(
+      '../../../src/commands/contact-properties/create'
+    );
+    await createContactPropertyCommand.parseAsync(
+      ['--key', 'company_name', '--type', 'string'],
+      { from: 'user' },
+    );
+
+    expect(mockCreate).toHaveBeenCalledTimes(1);
+    const args = mockCreate.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.key).toBe('company_name');
+    expect(args.type).toBe('string');
+  });
+
+  test('creates number-type property', async () => {
+    spies = setupOutputSpies();
+
+    const { createContactPropertyCommand } = await import(
+      '../../../src/commands/contact-properties/create'
+    );
+    await createContactPropertyCommand.parseAsync(
+      ['--key', 'score', '--type', 'number'],
+      { from: 'user' },
+    );
+
+    const args = mockCreate.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.key).toBe('score');
+    expect(args.type).toBe('number');
+  });
+
+  test('passes string fallback-value to SDK', async () => {
+    spies = setupOutputSpies();
+
+    const { createContactPropertyCommand } = await import(
+      '../../../src/commands/contact-properties/create'
+    );
+    await createContactPropertyCommand.parseAsync(
+      [
+        '--key',
+        'company_name',
+        '--type',
+        'string',
+        '--fallback-value',
+        'Unknown',
+      ],
+      { from: 'user' },
+    );
+
+    const args = mockCreate.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.fallbackValue).toBe('Unknown');
+  });
+
+  test('coerces fallback-value to number for number-type properties', async () => {
+    spies = setupOutputSpies();
+
+    const { createContactPropertyCommand } = await import(
+      '../../../src/commands/contact-properties/create'
+    );
+    await createContactPropertyCommand.parseAsync(
+      ['--key', 'score', '--type', 'number', '--fallback-value', '42'],
+      { from: 'user' },
+    );
+
+    const args = mockCreate.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.fallbackValue).toBe(42);
+  });
+
+  test('outputs JSON id when non-interactive', async () => {
+    spies = setupOutputSpies();
+
+    const { createContactPropertyCommand } = await import(
+      '../../../src/commands/contact-properties/create'
+    );
+    await createContactPropertyCommand.parseAsync(
+      ['--key', 'plan', '--type', 'string'],
+      { from: 'user' },
+    );
+
+    const output = spies.logSpy.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+    expect(parsed.object).toBe('contact_property');
+    expect(parsed.id).toBe('b4a3c2d1-6e5f-8a7b-0c9d-2e1f4a3b6c5d');
+  });
+
+  test('errors with missing_key in non-interactive mode', async () => {
+    setNonInteractive();
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { createContactPropertyCommand } = await import(
+      '../../../src/commands/contact-properties/create'
+    );
+    await expectExit1(() =>
+      createContactPropertyCommand.parseAsync(['--type', 'string'], {
+        from: 'user',
+      }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('missing_key');
+  });
+
+  test('errors with missing_type in non-interactive mode', async () => {
+    setNonInteractive();
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { createContactPropertyCommand } = await import(
+      '../../../src/commands/contact-properties/create'
+    );
+    await expectExit1(() =>
+      createContactPropertyCommand.parseAsync(['--key', 'company_name'], {
+        from: 'user',
+      }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('missing_type');
+  });
+
+  test('errors with invalid_fallback_value when number-type gets a non-numeric fallback', async () => {
+    setNonInteractive();
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { createContactPropertyCommand } = await import(
+      '../../../src/commands/contact-properties/create'
+    );
+    await expectExit1(() =>
+      createContactPropertyCommand.parseAsync(
+        [
+          '--key',
+          'score',
+          '--type',
+          'number',
+          '--fallback-value',
+          'not-a-number',
+        ],
+        { from: 'user' },
+      ),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('invalid_fallback_value');
+  });
+
+  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 { createContactPropertyCommand } = await import(
+      '../../../src/commands/contact-properties/create'
+    );
+    await expectExit1(() =>
+      createContactPropertyCommand.parseAsync(
+        ['--key', 'company_name', '--type', 'string'],
+        { 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('Key already exists', 'validation_error'),
+    );
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
+    exitSpy = mockExitThrow();
+
+    const { createContactPropertyCommand } = await import(
+      '../../../src/commands/contact-properties/create'
+    );
+    await expectExit1(() =>
+      createContactPropertyCommand.parseAsync(
+        ['--key', 'company_name', '--type', 'string'],
+        { from: 'user' },
+      ),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('create_error');
+  });
+});