@moxxy/plugin-channel-slack 0.27.0

package/src/subcommands.test.ts

@@ -0,0 +1,189 @@
+import { promises as fs } from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { VaultStore, createStaticKeySource, deriveKey, generateSalt } from '@moxxy/plugin-vault';
+import type { ChannelDef } from '@moxxy/sdk';
+import { buildSlackPlugin } from './index.js';
+import {
+  SLACK_AUTHORIZED_KEY,
+  SLACK_BOT_TOKEN_KEY,
+  SLACK_SIGNING_SECRET_KEY,
+} from './keys.js';
+
+let tmp: string;
+let vault: VaultStore;
+let slackDef: ChannelDef;
+let writeOut: string[];
+let writeErr: string[];
+let origStdoutWrite: typeof process.stdout.write;
+let origStderrWrite: typeof process.stderr.write;
+
+beforeEach(async () => {
+  tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'mox-slack-sub-'));
+  vault = new VaultStore({
+    filePath: path.join(tmp, 'vault.json'),
+    keySource: createStaticKeySource(deriveKey('test', generateSalt())),
+  });
+  const plugin = buildSlackPlugin({ vault });
+  slackDef = plugin.channels![0]!;
+  writeOut = [];
+  writeErr = [];
+  origStdoutWrite = process.stdout.write.bind(process.stdout);
+  origStderrWrite = process.stderr.write.bind(process.stderr);
+  process.stdout.write = ((chunk: string | Uint8Array) => {
+    writeOut.push(typeof chunk === 'string' ? chunk : Buffer.from(chunk).toString());
+    return true;
+  }) as typeof process.stdout.write;
+  process.stderr.write = ((chunk: string | Uint8Array) => {
+    writeErr.push(typeof chunk === 'string' ? chunk : Buffer.from(chunk).toString());
+    return true;
+  }) as typeof process.stderr.write;
+});
+
+afterEach(async () => {
+  await fs.rm(tmp, { recursive: true, force: true });
+  process.stdout.write = origStdoutWrite;
+  process.stderr.write = origStderrWrite;
+  delete process.env.MOXXY_SLACK_BOT_TOKEN;
+  delete process.env.MOXXY_SLACK_SIGNING_SECRET;
+});
+
+function ctx(overrides: { startChannel?: () => Promise<number> } = {}) {
+  return {
+    deps: { cwd: tmp, vault, logger: undefined, options: {} },
+    args: { positional: [], flags: {} },
+    startChannel: overrides.startChannel ?? (async () => 0),
+    session: { setPermissionResolver: () => {} },
+  } as never;
+}
+
+describe('slack channel subcommands (registered on ChannelDef)', () => {
+  it('exposes setup, pair, status, unpair', () => {
+    expect(slackDef.subcommands).toBeDefined();
+    expect(Object.keys(slackDef.subcommands!)).toEqual(
+      expect.arrayContaining(['setup', 'pair', 'status', 'unpair']),
+    );
+    expect(slackDef.interactiveCommand).toBe('setup');
+  });
+
+  it('`status` reports unconfigured vault state as JSON', async () => {
+    const code = await slackDef.subcommands!.status!.run(ctx());
+    expect(code).toBe(0);
+    const parsed = JSON.parse(writeOut.join(''));
+    expect(parsed).toEqual({
+      botTokenConfigured: false,
+      signingSecretConfigured: false,
+      authorized: null,
+      tunnelUrl: null,
+    });
+  });
+
+  it('`status` surfaces stored token + secret + authorization', async () => {
+    await vault.set(SLACK_BOT_TOKEN_KEY, 'xoxb-1111-2222-abcdefghijklmnop');
+    await vault.set(SLACK_SIGNING_SECRET_KEY, '0123456789abcdef0123456789abcdef');
+    await vault.set(
+      SLACK_AUTHORIZED_KEY,
+      JSON.stringify({ teamId: 'T1', channelId: 'C1' }),
+    );
+    const code = await slackDef.subcommands!.status!.run(ctx());
+    expect(code).toBe(0);
+    const parsed = JSON.parse(writeOut.join(''));
+    expect(parsed).toEqual({
+      botTokenConfigured: true,
+      signingSecretConfigured: true,
+      authorized: { teamId: 'T1', channelId: 'C1' },
+      tunnelUrl: null,
+    });
+  });
+
+  it('`status` honors env overrides for token/secret', async () => {
+    process.env.MOXXY_SLACK_BOT_TOKEN = 'xoxb-env-token-abcdefghijkl';
+    process.env.MOXXY_SLACK_SIGNING_SECRET = 'env-signing-secret-0123456789';
+    const code = await slackDef.subcommands!.status!.run(ctx());
+    expect(code).toBe(0);
+    const parsed = JSON.parse(writeOut.join(''));
+    expect(parsed.botTokenConfigured).toBe(true);
+    expect(parsed.signingSecretConfigured).toBe(true);
+  });
+
+  it('`status` reports null for a corrupt authorization record', async () => {
+    await vault.set(SLACK_AUTHORIZED_KEY, 'not-json');
+    const code = await slackDef.subcommands!.status!.run(ctx());
+    expect(code).toBe(0);
+    const parsed = JSON.parse(writeOut.join(''));
+    expect(parsed.authorized).toBeNull();
+  });
+
+  it('`unpair` clears the authorization and reports', async () => {
+    await vault.set(SLACK_AUTHORIZED_KEY, JSON.stringify({ teamId: 'T1' }));
+    const code = await slackDef.subcommands!.unpair!.run(ctx());
+    expect(code).toBe(0);
+    expect(writeOut.join('')).toContain('unpaired');
+    expect(await vault.get(SLACK_AUTHORIZED_KEY)).toBeNull();
+  });
+
+  it('`unpair` is a no-op when nothing is paired', async () => {
+    const code = await slackDef.subcommands!.unpair!.run(ctx());
+    expect(code).toBe(0);
+    expect(writeOut.join('')).toContain('no pairing was active');
+  });
+
+  it('`pair` refuses to start without a TTY (interactive-only flow)', async () => {
+    const originalIsTTY = process.stdin.isTTY;
+    Object.defineProperty(process.stdin, 'isTTY', { value: false, configurable: true });
+    try {
+      const startChannel = vi.fn(async () => 0);
+      const code = await slackDef.subcommands!.pair!.run(ctx({ startChannel }));
+      expect(code).toBe(1);
+      expect(startChannel).not.toHaveBeenCalled();
+      expect(writeErr.join('')).toMatch(/TTY/);
+    } finally {
+      Object.defineProperty(process.stdin, 'isTTY', { value: originalIsTTY, configurable: true });
+    }
+  });
+
+  it('`setup` starts the channel directly when not on a TTY', async () => {
+    const originalIsTTY = process.stdin.isTTY;
+    Object.defineProperty(process.stdin, 'isTTY', { value: false, configurable: true });
+    try {
+      const startChannel = vi.fn(async () => 0);
+      const code = await slackDef.subcommands!.setup!.run(ctx({ startChannel }));
+      expect(code).toBe(0);
+      expect(startChannel).toHaveBeenCalledTimes(1);
+    } finally {
+      Object.defineProperty(process.stdin, 'isTTY', { value: originalIsTTY, configurable: true });
+    }
+  });
+
+  it('subcommands return 1 when vault is unavailable', async () => {
+    const badCtx = {
+      deps: { cwd: tmp, vault: undefined, logger: undefined, options: {} },
+      args: { positional: [], flags: {} },
+      startChannel: async () => 0,
+      session: { setPermissionResolver: () => {} },
+    } as never;
+    const code = await slackDef.subcommands!.status!.run(badCtx);
+    expect(code).toBe(1);
+    expect(writeErr.join('')).toContain('vault unavailable');
+  });
+
+  it('isAvailable gates on BOTH token and secret', async () => {
+    // Neither set → unavailable, reason names both.
+    let avail = await slackDef.isAvailable!({ cwd: tmp, vault });
+    expect(avail.ok).toBe(false);
+    expect(avail.reason).toMatch(/bot token/);
+    expect(avail.reason).toMatch(/signing secret/);
+
+    // Only token → still unavailable, reason names the secret.
+    await vault.set(SLACK_BOT_TOKEN_KEY, 'xoxb-1111-2222-abcdefghijklmnop');
+    avail = await slackDef.isAvailable!({ cwd: tmp, vault });
+    expect(avail.ok).toBe(false);
+    expect(avail.reason).toMatch(/signing secret/);
+
+    // Both → available.
+    await vault.set(SLACK_SIGNING_SECRET_KEY, '0123456789abcdef0123456789abcdef');
+    avail = await slackDef.isAvailable!({ cwd: tmp, vault });
+    expect(avail.ok).toBe(true);
+  });
+});