switchroom 0.10.0 → 0.11.1

package/telegram-plugin/tests/auto-fallback-dispatcher.e2e.test.ts

@@ -1,183 +0,0 @@
-/**
- * End-to-end tests for the auto-fallback notification dispatcher
- * (#11 / #420 / #421).
- *
- * `auto-fallback.ts` returns a `FallbackPlan` (pure). This test
- * exercises the side-effecting half: given a plan, does the
- * dispatcher emit the right Bot API call to the owner chat?
- *
- * The pure plan logic itself is covered by `auto-fallback.test.ts`.
- * This file locks in the wiring so a regression in dispatch (wrong
- * parse_mode, missing link-preview disable, swallowed errors) is
- * caught here instead of going silent in production.
- */
-
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import {
-  dispatchFallbackNotification,
-  type DispatchOutcome,
-} from '../auto-fallback-dispatcher.js';
-import type { FallbackPlan } from '../auto-fallback.js';
-import { createFakeBotApi, errors, type FakeBot } from './fake-bot-api.js';
-
-const OWNER = 'chat-owner';
-
-let bot: FakeBot;
-
-beforeEach(() => {
-  bot = createFakeBotApi({ startMessageId: 200 });
-});
-
-function planExecuted(): FallbackPlan {
-  return {
-    kind: 'executed',
-    previousSlot: 'default',
-    newSlot: 'personal',
-    resetAtMs: Date.now() + 60_000,
-    notificationHtml:
-      '⚠️ <b>Quota exhausted</b> on slot <code>default</code>. Switched to <code>personal</code>.',
-    agentName: 'clerk',
-    triggerReason: '429-response',
-  };
-}
-
-function planExhaustedAll(): FallbackPlan {
-  return {
-    kind: 'exhausted-all',
-    activeSlot: 'default',
-    resetAtMs: Date.now() + 4 * 60 * 60_000,
-    notificationHtml:
-      '🚨 <b>All slots quota-exhausted</b> for clerk. Run /auth add to attach another subscription.',
-    agentName: 'clerk',
-  };
-}
-
-describe('dispatchFallbackNotification — happy path', () => {
-  it('sends executed plan with HTML parse_mode + link preview disabled', async () => {
-    const plan = planExecuted();
-    const outcome = await dispatchFallbackNotification({
-      bot,
-      ownerChatId: OWNER,
-      plan,
-    });
-    expect(outcome).toEqual<DispatchOutcome>({ kind: 'sent', messageId: 200 });
-    expect(bot.api.sendMessage).toHaveBeenCalledTimes(1);
-    const [chat, text, opts] = bot.api.sendMessage.mock.calls[0];
-    expect(chat).toBe(OWNER);
-    expect(text).toBe(plan.notificationHtml);
-    expect(opts).toMatchObject({
-      parse_mode: 'HTML',
-      link_preview_options: { is_disabled: true },
-    });
-  });
-
-  it('sends exhausted-all plan to owner chat', async () => {
-    const plan = planExhaustedAll();
-    const outcome = await dispatchFallbackNotification({
-      bot,
-      ownerChatId: OWNER,
-      plan,
-    });
-    expect(outcome.kind).toBe('sent');
-    const text = bot.api.sendMessage.mock.calls[0][1] as string;
-    expect(text).toContain('All slots quota-exhausted');
-    expect(text).toContain('clerk');
-  });
-
-  it('chat model reflects the sent message', async () => {
-    await dispatchFallbackNotification({
-      bot,
-      ownerChatId: OWNER,
-      plan: planExecuted(),
-    });
-    const sent = bot.messagesIn(OWNER);
-    expect(sent).toHaveLength(1);
-    expect(sent[0].text).toContain('Quota exhausted');
-    expect(sent[0].parse_mode).toBe('HTML');
-  });
-});
-
-describe('dispatchFallbackNotification — no chat', () => {
-  it('returns no-chat when ownerChatId is null', async () => {
-    const outcome = await dispatchFallbackNotification({
-      bot,
-      ownerChatId: null,
-      plan: planExecuted(),
-    });
-    expect(outcome).toEqual({ kind: 'no-chat' });
-    expect(bot.api.sendMessage).not.toHaveBeenCalled();
-  });
-
-  it('returns no-chat when ownerChatId is undefined (access.allowFrom empty)', async () => {
-    const outcome = await dispatchFallbackNotification({
-      bot,
-      ownerChatId: undefined,
-      plan: planExecuted(),
-    });
-    expect(outcome).toEqual({ kind: 'no-chat' });
-    expect(bot.api.sendMessage).not.toHaveBeenCalled();
-  });
-
-  it('returns no-chat for empty string', async () => {
-    const outcome = await dispatchFallbackNotification({
-      bot,
-      ownerChatId: '',
-      plan: planExecuted(),
-    });
-    expect(outcome).toEqual({ kind: 'no-chat' });
-    expect(bot.api.sendMessage).not.toHaveBeenCalled();
-  });
-});
-
-describe('dispatchFallbackNotification — error paths', () => {
-  it('forbidden error (bot blocked) is reported via onError, never throws', async () => {
-    bot.faults.next('sendMessage', errors.forbidden());
-    const onError = vi.fn();
-    const outcome = await dispatchFallbackNotification({
-      bot,
-      ownerChatId: OWNER,
-      plan: planExecuted(),
-      onError,
-    });
-    expect(outcome).toEqual({ kind: 'error' });
-    expect(onError).toHaveBeenCalledTimes(1);
-    expect(onError).toHaveBeenCalledWith(expect.any(Error));
-  });
-
-  it('flood-wait error is reported via onError, never throws', async () => {
-    bot.faults.next('sendMessage', errors.floodWait(15));
-    const onError = vi.fn();
-    const outcome = await dispatchFallbackNotification({
-      bot,
-      ownerChatId: OWNER,
-      plan: planExhaustedAll(),
-      onError,
-    });
-    expect(outcome).toEqual({ kind: 'error' });
-    expect(onError).toHaveBeenCalledWith(expect.any(Error));
-  });
-
-  it('network error is reported via onError, never throws', async () => {
-    bot.faults.next('sendMessage', errors.networkError('ECONNRESET'));
-    const onError = vi.fn();
-    const outcome = await dispatchFallbackNotification({
-      bot,
-      ownerChatId: OWNER,
-      plan: planExecuted(),
-      onError,
-    });
-    expect(outcome).toEqual({ kind: 'error' });
-    expect(onError).toHaveBeenCalledWith(expect.any(Error));
-  });
-
-  it('omitted onError still resolves cleanly on failure', async () => {
-    bot.faults.next('sendMessage', errors.forbidden());
-    // No onError supplied — should not throw, just return error outcome.
-    const outcome = await dispatchFallbackNotification({
-      bot,
-      ownerChatId: OWNER,
-      plan: planExecuted(),
-    });
-    expect(outcome).toEqual({ kind: 'error' });
-  });
-});

package/telegram-plugin/tests/hostd-dispatch.test.ts

@@ -1,129 +0,0 @@
-/**
- * Unit tests for `hostd-dispatch.ts` — the gateway's helper that routes
- * self-restart slash-commands through the hostd UDS when enabled.
- *
- * The config-loading branches are validated by mocking
- * `loadSwitchroomConfig` (the schema's complexity isn't this test's
- * concern — we just need to feed it a known value). The wire-error
- * branch is validated by pointing the helper at a nonexistent socket.
- *
- * The "actually hits a real hostd" path is covered in
- * `tests/host-control/server.test.ts` end-to-end — we don't re-test
- * the server here.
- */
-
-import {
-  describe,
-  it,
-  expect,
-  beforeEach,
-  afterEach,
-  vi,
-} from "vitest";
-
-const loadConfigMock = vi.fn();
-vi.mock("../../src/config/loader.js", () => ({
-  loadConfig: loadConfigMock,
-}));
-
-// Import AFTER the mock so the module captures the mocked function.
-const {
-  tryHostdDispatch,
-  hostdWillBeUsed,
-  isHostdEnabled,
-  hostdSocketPath,
-  _resetHostdEnabledCache,
-} = await import("../gateway/hostd-dispatch.js");
-
-beforeEach(() => {
-  _resetHostdEnabledCache();
-  loadConfigMock.mockReset();
-});
-
-afterEach(() => {
-  _resetHostdEnabledCache();
-});
-
-describe("isHostdEnabled() — config gate", () => {
-  it("returns false when host_control absent", () => {
-    loadConfigMock.mockReturnValue({});
-    expect(isHostdEnabled()).toBe(false);
-  });
-
-  it("returns false when host_control.enabled is false", () => {
-    loadConfigMock.mockReturnValue({ host_control: { enabled: false } });
-    expect(isHostdEnabled()).toBe(false);
-  });
-
-  it("returns true when host_control.enabled is true", () => {
-    loadConfigMock.mockReturnValue({ host_control: { enabled: true } });
-    expect(isHostdEnabled()).toBe(true);
-  });
-
-  it("returns false on config-load throw (best-effort fallback)", () => {
-    // Gateway runs in environments where the config may not be
-    // readable yet (very-early-boot, broken symlink). The helper must
-    // not propagate — it just disables the hostd path.
-    loadConfigMock.mockImplementation(() => {
-      throw new Error("config: file not found");
-    });
-    expect(isHostdEnabled()).toBe(false);
-  });
-
-  it("caches the result across calls (no re-read)", () => {
-    loadConfigMock.mockReturnValue({ host_control: { enabled: true } });
-    expect(isHostdEnabled()).toBe(true);
-    expect(isHostdEnabled()).toBe(true);
-    expect(isHostdEnabled()).toBe(true);
-    expect(loadConfigMock).toHaveBeenCalledTimes(1);
-  });
-});
-
-describe("hostdWillBeUsed() — config + socket existence", () => {
-  it("false when hostd disabled even if socket would be present", () => {
-    loadConfigMock.mockReturnValue({});
-    expect(hostdWillBeUsed("klanker")).toBe(false);
-  });
-
-  it("false when hostd enabled but per-agent socket isn't bound", () => {
-    loadConfigMock.mockReturnValue({ host_control: { enabled: true } });
-    // hostdSocketPath() is hard-coded to /run/switchroom/hostd/<name>/sock
-    // — that path doesn't exist in the test env, so existsSync returns
-    // false and hostdWillBeUsed is false.
-    expect(hostdWillBeUsed("klanker-no-such-agent")).toBe(false);
-  });
-});
-
-describe("tryHostdDispatch()", () => {
-  it("returns 'not-configured' when hostd disabled", async () => {
-    loadConfigMock.mockReturnValue({});
-    const result = await tryHostdDispatch("klanker", {
-      v: 1,
-      op: "agent_restart",
-      request_id: "test-1",
-      args: { name: "klanker", force: true },
-    });
-    expect(result).toBe("not-configured");
-  });
-
-  it("returns 'not-configured' when socket absent", async () => {
-    loadConfigMock.mockReturnValue({ host_control: { enabled: true } });
-    const result = await tryHostdDispatch("nonexistent-agent", {
-      v: 1,
-      op: "agent_restart",
-      request_id: "test-2",
-      args: { name: "nonexistent-agent", force: true },
-    });
-    expect(result).toBe("not-configured");
-  });
-
-  it("locks the socket-path contract", () => {
-    // RFC C pins this path. If the gateway and the compose generator
-    // drift apart on the bind path, the mount silently goes nowhere
-    // and every dispatch returns "not-configured". Catch any rename
-    // in lockstep with the compose-generator test.
-    expect(hostdSocketPath("klanker")).toBe(
-      "/run/switchroom/hostd/klanker/sock",
-    );
-  });
-});