@poetic-ai/poetic 1.42.0

package/integrations/bb-plugin-poetic/tests/host-contract.test.ts

@@ -0,0 +1,773 @@
+import { createFakePluginHost } from '@bb/plugin-sdk/testing';
+import { afterEach, describe, expect, it } from 'vitest';
+import plugin, { POETIC_MONITOR_SERVICE_NAME, POETIC_PLUGIN_VERSION } from '../server.js';
+import { poeticRpcContract } from '../src/contract.js';
+import {
+  applyTaskActionInputSchema,
+  applyTaskActionMethod,
+  applyTaskActionOutputSchema,
+  LIVE_POETIC_RPC_METHODS,
+  ProcessLocalTaskActionAdmission,
+  TASK_ACTION_REASON_KINDS,
+  TASK_ACTION_TERMINAL_KINDS,
+  TASK_ACTION_VOCABULARY,
+  TASK_PLANNING_DISCLOSURE,
+  taskActionConsentSchema,
+  taskActionTerminalConsentSchema,
+  taskPlanningDisclosureSchema,
+} from '../src/model.js';
+import { SPRINT_COMPOSITION_VOCABULARY } from '../src/sprint-composition-schema.js';
+import { TASK_AUTHORING_VOCABULARY } from '../src/task-authoring-schema.js';
+
+const target = { projectId: 'project-1', sourceId: 'source-1', taskId: 'task-1' };
+
+const baseConsent = {
+  hostExecution: true as const,
+  managedPlanningMutation: true as const,
+  automaticCommitAndPush: true as const,
+  selectedRepositoryAndBranch: true as const,
+};
+
+const terminalConsent = {
+  ...baseConsent,
+  archivalOrTerminalConfirmation: true as const,
+};
+
+describe('BB task-action contract shapes', () => {
+  it('freezes the closed action vocabulary and applyTaskAction method', () => {
+    expect(TASK_ACTION_VOCABULARY).toEqual([
+      'start',
+      'block',
+      'unblock',
+      'review',
+      'complete',
+      'cancel',
+      'reopen',
+    ]);
+    expect(TASK_ACTION_REASON_KINDS).toEqual(['block', 'cancel', 'reopen']);
+    expect(TASK_ACTION_TERMINAL_KINDS).toEqual(['complete', 'cancel', 'reopen']);
+    expect(applyTaskActionMethod.input).toBe(applyTaskActionInputSchema);
+    expect(applyTaskActionMethod.output).toBe(applyTaskActionOutputSchema);
+    // The frozen method is now registered on the live surface (BPTA-06) without
+    // expanding the public vocabulary.
+    expect(LIVE_POETIC_RPC_METHODS).toContain('applyTaskAction');
+  });
+
+  it('accepts every closed action shape with required consent and reasons', () => {
+    const accepted = [
+      { ...target, action: 'start' as const, consent: baseConsent },
+      {
+        ...target,
+        action: 'block' as const,
+        reason: 'Waiting on external review',
+        consent: baseConsent,
+      },
+      { ...target, action: 'unblock' as const, consent: baseConsent },
+      { ...target, action: 'review' as const, consent: baseConsent },
+      { ...target, action: 'complete' as const, consent: terminalConsent },
+      {
+        ...target,
+        action: 'cancel' as const,
+        reason: 'No longer needed',
+        consent: terminalConsent,
+      },
+      {
+        ...target,
+        action: 'reopen' as const,
+        reason: 'Issue reproduced',
+        consent: terminalConsent,
+      },
+    ];
+
+    for (const request of accepted) {
+      const parsed = applyTaskActionInputSchema.safeParse(request);
+      expect(parsed.success, JSON.stringify(request)).toBe(true);
+    }
+  });
+
+  it('requires reasons for block, cancel, and reopen only', () => {
+    expect(
+      applyTaskActionInputSchema.safeParse({
+        ...target,
+        action: 'block',
+        consent: baseConsent,
+      }).success
+    ).toBe(false);
+    expect(
+      applyTaskActionInputSchema.safeParse({
+        ...target,
+        action: 'block',
+        reason: '   ',
+        consent: baseConsent,
+      }).success
+    ).toBe(false);
+    expect(
+      applyTaskActionInputSchema.safeParse({
+        ...target,
+        action: 'cancel',
+        consent: terminalConsent,
+      }).success
+    ).toBe(false);
+    expect(
+      applyTaskActionInputSchema.safeParse({
+        ...target,
+        action: 'reopen',
+        consent: terminalConsent,
+      }).success
+    ).toBe(false);
+    // Start/unblock/review/complete must not require or accept a reason field.
+    expect(
+      applyTaskActionInputSchema.safeParse({
+        ...target,
+        action: 'start',
+        reason: 'extra',
+        consent: baseConsent,
+      }).success
+    ).toBe(false);
+    expect(
+      applyTaskActionInputSchema.safeParse({
+        ...target,
+        action: 'complete',
+        reason: 'done',
+        consent: terminalConsent,
+      }).success
+    ).toBe(false);
+  });
+
+  it('requires archival/terminal confirmation for complete, cancel, and reopen', () => {
+    expect(
+      applyTaskActionInputSchema.safeParse({
+        ...target,
+        action: 'complete',
+        consent: baseConsent,
+      }).success
+    ).toBe(false);
+    expect(
+      applyTaskActionInputSchema.safeParse({
+        ...target,
+        action: 'cancel',
+        reason: 'dropped',
+        consent: baseConsent,
+      }).success
+    ).toBe(false);
+    expect(
+      applyTaskActionInputSchema.safeParse({
+        ...target,
+        action: 'reopen',
+        reason: 'retry',
+        consent: baseConsent,
+      }).success
+    ).toBe(false);
+    expect(
+      applyTaskActionInputSchema.safeParse({
+        ...target,
+        action: 'start',
+        consent: terminalConsent,
+      }).success
+    ).toBe(false);
+  });
+
+  it('rejects force, no-sync, executable, argv, cwd, env, update, and matrix surfaces', () => {
+    const rejected = [
+      {
+        ...target,
+        action: 'complete',
+        force: true,
+        consent: terminalConsent,
+      },
+      {
+        ...target,
+        action: 'start',
+        noSync: true,
+        consent: baseConsent,
+      },
+      {
+        ...target,
+        action: 'start',
+        sync: false,
+        consent: baseConsent,
+      },
+      {
+        ...target,
+        action: 'block',
+        reason: 'blocked',
+        consent: baseConsent,
+        executable: 'bash',
+      },
+      {
+        ...target,
+        action: 'review',
+        consent: baseConsent,
+        argv: ['plan', 'task', 'update'],
+      },
+      {
+        ...target,
+        action: 'unblock',
+        consent: baseConsent,
+        cwd: '/tmp',
+      },
+      {
+        ...target,
+        action: 'start',
+        consent: baseConsent,
+        env: { POETIC_ROOT: '/tmp' },
+      },
+      {
+        ...target,
+        action: 'update',
+        consent: baseConsent,
+        title: 'rewrite',
+      },
+      {
+        ...target,
+        action: 'start',
+        consent: baseConsent,
+        to: 'done',
+      },
+      {
+        ...target,
+        action: 'unblock',
+        consent: baseConsent,
+        targetStatus: 'done',
+      },
+      {
+        ...target,
+        action: 'transition',
+        from: 'todo',
+        to: 'done',
+        consent: baseConsent,
+      },
+      {
+        projectId: 'project-1',
+        sourceId: 'source-1',
+        action: 'start',
+        consent: baseConsent,
+      },
+      {
+        ...target,
+        action: 'start',
+        consent: {
+          ...baseConsent,
+          hostExecution: false,
+        },
+      },
+    ];
+
+    for (const request of rejected) {
+      expect(applyTaskActionInputSchema.safeParse(request).success, JSON.stringify(request)).toBe(
+        false
+      );
+    }
+  });
+
+  it('validates task-planning disclosure and consent schemas strictly', () => {
+    expect(taskPlanningDisclosureSchema.safeParse(TASK_PLANNING_DISCLOSURE).success).toBe(true);
+    expect(taskActionConsentSchema.safeParse(baseConsent).success).toBe(true);
+    expect(taskActionTerminalConsentSchema.safeParse(terminalConsent).success).toBe(true);
+    expect(
+      taskActionConsentSchema.safeParse({
+        ...baseConsent,
+        archivalOrTerminalConfirmation: true,
+      }).success
+    ).toBe(false);
+    expect(
+      taskPlanningDisclosureSchema.safeParse({
+        ...TASK_PLANNING_DISCLOSURE,
+        pullRequestCreation: true,
+      }).success
+    ).toBe(false);
+  });
+
+  it('provides process-local admission without claiming cross-process ownership', () => {
+    const admission = new ProcessLocalTaskActionAdmission();
+    const scope = { repositoryPath: '/repo/a', taskId: 'task-1' };
+    const otherTask = { repositoryPath: '/repo/a', taskId: 'task-2' };
+    const otherRepo = { repositoryPath: '/repo/b', taskId: 'task-1' };
+
+    const release = admission.claim(scope);
+    expect(admission.isBusy(scope)).toBe(true);
+    expect(() => admission.claim(scope)).toThrow(/Process-local admission/);
+    expect(() => admission.claim(scope)).toThrow(/not cross-process ownership/);
+    expect(admission.isBusy(otherTask)).toBe(false);
+    expect(admission.isBusy(otherRepo)).toBe(false);
+    const releaseOther = admission.claim(otherTask);
+    release();
+    expect(admission.isBusy(scope)).toBe(false);
+    release(); // idempotent
+    admission.claim(scope)();
+    releaseOther();
+  });
+});
+
+describe('Poetic plugin in the official BB fake host', () => {
+  const disposers: Array<() => Promise<void>> = [];
+
+  afterEach(async () => {
+    await Promise.all(disposers.splice(0).map((dispose) => dispose()));
+  });
+
+  it('loads and registers the complete RPC contract', async () => {
+    const { bb, harness } = createFakePluginHost({ pluginId: 'poetic' });
+    disposers.push(() => harness.dispose());
+
+    await plugin(bb);
+
+    expect(harness.registrations.rpcMethods).toEqual([...LIVE_POETIC_RPC_METHODS]);
+    expect(harness.logEntries).toContainEqual({
+      level: 'info',
+      message: `Poetic ${POETIC_PLUGIN_VERSION} loaded`,
+    });
+  });
+
+  /**
+   * BRCS-07 registers the approved read and preview methods on the live surface.
+   * The complete list is pinned above; this case pins the additions themselves and
+   * that each one is registered exactly once.
+   */
+  it('registers each approved read and preview method exactly once', async () => {
+    const { bb, harness } = createFakePluginHost({ pluginId: 'poetic' });
+    disposers.push(() => harness.dispose());
+
+    await plugin(bb);
+
+    const registered = harness.registrations.rpcMethods;
+    for (const method of ['readResult', 'previewPatch', 'competitionDefaults', 'setupStatus']) {
+      expect(LIVE_POETIC_RPC_METHODS).toContain(method);
+      expect(registered.filter((name) => name === method)).toEqual([method]);
+    }
+    expect(new Set(registered).size).toBe(registered.length);
+  });
+
+  /**
+   * BPAU-07A's registration delta, pinned as the complete resulting list.
+   *
+   * The three mutation names are frozen by BPAU-00; the two sprint reads were not
+   * registered before this sprint. Nothing pre-existing is removed, renamed,
+   * combined, or reordered, and every name is registered exactly once.
+   */
+  it('pins the full RPC list after the BPAU-07A registration delta', () => {
+    expect(LIVE_POETIC_RPC_METHODS).toEqual([
+      'listProjects',
+      'capabilities',
+      'listBacklog',
+      'planningWorkspace',
+      'getBacklog',
+      'getTask',
+      'launchFusion',
+      'launchCompetition',
+      'launchTrackedBacklog',
+      'observeCompetition',
+      'pollRuns',
+      'cancelRun',
+      'applyTaskAction',
+      'readResult',
+      'previewPatch',
+      'competitionDefaults',
+      'setupStatus',
+      'applyBacklogAuthoring',
+      'applyTaskAuthoring',
+      'applySprintComposition',
+      'listSprints',
+      'getSprint',
+      'applyBacklogFinalize',
+      'applySprintClose',
+    ]);
+    expect(new Set(LIVE_POETIC_RPC_METHODS).size).toBe(LIVE_POETIC_RPC_METHODS.length);
+  });
+
+  it('accepts optional pollRuns observe and fresh without extra keys', () => {
+    const input = poeticRpcContract.pollRuns.input;
+    expect(input.safeParse({ projectId: 'project-1', sourceId: 'source-1' }).success).toBe(true);
+    expect(
+      input.safeParse({
+        projectId: 'project-1',
+        sourceId: 'source-1',
+        observe: false,
+        fresh: true,
+      }).success
+    ).toBe(true);
+    expect(
+      input.safeParse({ projectId: 'project-1', sourceId: 'source-1', extra: true }).success
+    ).toBe(false);
+  });
+
+  it('registers each planning-authoring method exactly once on the live host', async () => {
+    const { bb, harness } = createFakePluginHost({ pluginId: 'poetic' });
+    disposers.push(() => harness.dispose());
+
+    await plugin(bb);
+
+    const registered = harness.registrations.rpcMethods;
+    for (const method of [
+      'applyBacklogAuthoring',
+      'applyTaskAuthoring',
+      'applySprintComposition',
+      'listSprints',
+      'getSprint',
+      'applyBacklogFinalize',
+      'applySprintClose',
+    ]) {
+      expect(registered.filter((name) => name === method)).toEqual([method]);
+    }
+    // No prohibited planning action reached the live surface.
+    for (const absent of [
+      'deferBacklogItem',
+      'archiveBacklogItem',
+      'refineBacklogItem',
+      'splitTask',
+      'logTaskTime',
+      'completeSprint',
+      'closeSprint',
+      'pruneMissingSprintTasks',
+      'runSprint',
+      'applySprint',
+      'sprintCapacity',
+      'updateTask',
+      'createTask',
+      'runPoeticCommand',
+    ]) {
+      expect(registered).not.toContain(absent);
+      expect(LIVE_POETIC_RPC_METHODS).not.toContain(absent);
+    }
+  });
+
+  /**
+   * The authoring vocabularies stay disjoint from the lifecycle vocabulary, so an
+   * authoring control can never reach a status transition.
+   */
+  it('keeps the authoring vocabularies disjoint from task lifecycle actions', () => {
+    const lifecycle = new Set<string>(TASK_ACTION_VOCABULARY);
+    for (const action of TASK_AUTHORING_VOCABULARY) expect(lifecycle.has(action)).toBe(false);
+    for (const action of SPRINT_COMPOSITION_VOCABULARY) expect(lifecycle.has(action)).toBe(false);
+    expect(TASK_AUTHORING_VOCABULARY).toEqual([
+      'createCustomTask',
+      'updateCustomTask',
+      'addTaskDependency',
+      'removeTaskDependency',
+      'linkTaskToBacklog',
+    ]);
+    expect(SPRINT_COMPOSITION_VOCABULARY).toEqual([
+      'createSprint',
+      'renameSprint',
+      'addSprintWorkFromBacklog',
+      'removeSprintTask',
+      'migrateSprintTask',
+    ]);
+  });
+
+  it('validates planning-authoring input at the host boundary', async () => {
+    const { bb, harness } = createFakePluginHost({
+      pluginId: 'poetic',
+      sdk: {
+        system: { config: async () => ({ primaryHostId: 'host-local' }) },
+        projects: {
+          list: async () => [
+            {
+              id: 'project-1',
+              name: 'Poetic',
+              sources: [
+                { id: 'source-1', type: 'local_path', hostId: 'host-local', path: '/tmp/poetic' },
+              ],
+            },
+          ],
+        },
+      },
+    });
+    disposers.push(() => harness.dispose());
+    await plugin(bb);
+
+    const authoringConsent = {
+      hostExecution: true,
+      managedPlanningMutation: true,
+      automaticCommitAndPush: true,
+      selectedRepositoryAndBranch: true,
+    };
+    const invalid = { code: 'invalid_input' };
+
+    // No `--force`, `--no-sync`, `--body-file`, or path field exists in the schema.
+    await expect(
+      harness.callRpc('applyBacklogAuthoring', {
+        projectId: 'project-1',
+        sourceId: 'source-1',
+        action: 'reviewBacklogItem',
+        input: { backlogItemId: 'item-1' },
+        expected: { repository: '/tmp/poetic', branch: 'work' },
+        consent: { ...authoringConsent, launchEligibilityChange: true },
+        force: true,
+      })
+    ).rejects.toMatchObject(invalid);
+    // Review requires the launch-eligibility acknowledgement.
+    await expect(
+      harness.callRpc('applyBacklogAuthoring', {
+        projectId: 'project-1',
+        sourceId: 'source-1',
+        action: 'reviewBacklogItem',
+        input: { backlogItemId: 'item-1' },
+        expected: { repository: '/tmp/poetic', branch: 'work' },
+        consent: authoringConsent,
+      })
+    ).rejects.toMatchObject(invalid);
+    // A lifecycle action is not part of the authoring vocabulary.
+    await expect(
+      harness.callRpc('applyTaskAuthoring', {
+        projectId: 'project-1',
+        sourceId: 'source-1',
+        action: 'complete',
+        input: { taskId: 'task-1' },
+        consent: authoringConsent,
+      })
+    ).rejects.toMatchObject(invalid);
+    // Splitting is excluded, so no splitter option can reach the sprint lane.
+    await expect(
+      harness.callRpc('applySprintComposition', {
+        projectId: 'project-1',
+        sourceId: 'source-1',
+        action: 'addSprintWorkFromBacklog',
+        input: { sprintId: 'sprint-1', backlogItemId: 'item-1', estimate: 4, split: true },
+        expected: { repository: '/tmp/poetic', branch: 'work', entityIds: [] },
+        consent: authoringConsent,
+      })
+    ).rejects.toMatchObject(invalid);
+    // Sprint reads always name an explicit, safe single-component id.
+    await expect(
+      harness.callRpc('getSprint', {
+        projectId: 'project-1',
+        sourceId: 'source-1',
+        sprintId: '../etc/passwd',
+      })
+    ).rejects.toMatchObject(invalid);
+    await expect(
+      harness.callRpc('getSprint', { projectId: 'project-1', sourceId: 'source-1' })
+    ).rejects.toMatchObject(invalid);
+    await expect(
+      harness.callRpc('listSprints', {
+        projectId: 'project-1',
+        sourceId: 'source-1',
+        scope: 'everything',
+      })
+    ).rejects.toMatchObject(invalid);
+    // Finalize requires every high-consent literal and rejects --auto / argv.
+    await expect(
+      harness.callRpc('applyBacklogFinalize', {
+        projectId: 'project-1',
+        sourceId: 'source-1',
+        backlogItemId: 'item-1',
+        pr: 12,
+        commit: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+        expected: { repository: '/tmp/poetic', branch: 'work' },
+        consent: {
+          hostExecution: true,
+          managedPlanningSync: true,
+          finalizeArchivesOrLifecycleUpdatesItem: true,
+        },
+      })
+    ).rejects.toMatchObject(invalid);
+    await expect(
+      harness.callRpc('applyBacklogFinalize', {
+        projectId: 'project-1',
+        sourceId: 'source-1',
+        backlogItemId: 'item-1',
+        pr: 12,
+        commit: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+        expected: { repository: '/tmp/poetic', branch: 'work' },
+        consent: {
+          hostExecution: true,
+          managedPlanningSync: true,
+          finalizeArchivesOrLifecycleUpdatesItem: true,
+          prAndCommitArePoeticPublished: true,
+        },
+        auto: true,
+      })
+    ).rejects.toMatchObject(invalid);
+    // Close requires high consent and rejects --force / --archive-backlog.
+    await expect(
+      harness.callRpc('applySprintClose', {
+        projectId: 'project-1',
+        sourceId: 'source-1',
+        sprintId: 'sprint-1',
+        expected: { repository: '/tmp/poetic', branch: 'work' },
+        consent: { hostExecution: true, managedPlanningSync: true },
+      })
+    ).rejects.toMatchObject(invalid);
+    await expect(
+      harness.callRpc('applySprintClose', {
+        projectId: 'project-1',
+        sourceId: 'source-1',
+        sprintId: 'sprint-1',
+        expected: { repository: '/tmp/poetic', branch: 'work' },
+        consent: {
+          hostExecution: true,
+          managedPlanningSync: true,
+          closeCompletesTheNamedSprint: true,
+        },
+        force: true,
+        archiveBacklog: true,
+      })
+    ).rejects.toMatchObject(invalid);
+  });
+
+  it('registers its authoritative polling service through the official host', async () => {
+    const { bb, harness } = createFakePluginHost({ pluginId: 'poetic' });
+    disposers.push(() => harness.dispose());
+    const services: string[] = [];
+    const registerService = bb.background.service.bind(bb.background);
+    // Observe the real host call rather than depending on a harness field name.
+    (bb.background as { service: typeof bb.background.service }).service = (name, service) => {
+      services.push(name);
+      registerService(name, service);
+    };
+
+    await plugin(bb);
+
+    // The BB background service owns the cadence: exactly one service, and no
+    // cron schedule or second polling mechanism.
+    expect(services).toEqual([POETIC_MONITOR_SERVICE_NAME]);
+  });
+
+  /**
+   * The planning workspace reuses the configured Poetic executable and must not
+   * add a second public configuration key.
+   */
+  it('adds no public configuration for the planning workspace', async () => {
+    const { bb, harness } = createFakePluginHost({ pluginId: 'poetic' });
+    disposers.push(() => harness.dispose());
+    const settingsKeys: string[] = [];
+    const defineSettings = bb.settings.define.bind(bb.settings);
+    (bb.settings as { define: typeof bb.settings.define }).define = (descriptors) => {
+      settingsKeys.push(...Object.keys(descriptors));
+      return defineSettings(descriptors);
+    };
+
+    await plugin(bb);
+
+    expect(settingsKeys).toEqual(['poeticExecutable']);
+  });
+
+  it('stops the background service on host disposal', async () => {
+    const { bb, harness } = createFakePluginHost({ pluginId: 'poetic' });
+    await plugin(bb);
+
+    await harness.dispose();
+
+    // Teardown is the plugin load's own lifetime: nothing outlives dispose.
+    expect(harness.logEntries).toContainEqual({
+      level: 'info',
+      message: `Poetic ${POETIC_PLUGIN_VERSION} monitor stopped`,
+    });
+  });
+
+  it('uses official host input validation and SDK routing', async () => {
+    const { bb, harness } = createFakePluginHost({
+      pluginId: 'poetic',
+      sdk: {
+        system: { config: async () => ({ primaryHostId: 'host-local' }) },
+        projects: {
+          list: async () => [
+            {
+              id: 'project-1',
+              name: 'Poetic',
+              sources: [
+                {
+                  id: 'source-1',
+                  type: 'local_path',
+                  hostId: 'host-local',
+                  path: '/tmp/poetic',
+                },
+              ],
+            },
+          ],
+        },
+      },
+    });
+    disposers.push(() => harness.dispose());
+    await plugin(bb);
+
+    await expect(harness.callRpc('listProjects', { unexpected: true })).rejects.toMatchObject({
+      code: 'invalid_input',
+    });
+    await expect(
+      harness.callRpc('launchTrackedBacklog', {
+        projectId: 'project-1',
+        sourceId: 'source-1',
+        backlogItemId: 'PBB-18',
+        consent: {
+          hostExecution: true,
+          cleanCheckoutRequired: true,
+          branchChanges: true,
+          managedPlanningSync: true,
+          providerAuth: true,
+          gitCommitsAndPush: false,
+          pullRequestCreation: true,
+          finalizationIsSeparate: true,
+        },
+      })
+    ).rejects.toMatchObject({ code: 'invalid_input' });
+    // The registered task-action method rejects incomplete consent and any
+    // out-of-vocabulary surface at the host boundary, before the adapter runs.
+    await expect(
+      harness.callRpc('applyTaskAction', {
+        projectId: 'project-1',
+        sourceId: 'source-1',
+        taskId: 'task-1',
+        action: 'complete',
+        consent: baseConsent,
+      })
+    ).rejects.toMatchObject({ code: 'invalid_input' });
+    await expect(
+      harness.callRpc('applyTaskAction', {
+        projectId: 'project-1',
+        sourceId: 'source-1',
+        taskId: 'task-1',
+        action: 'start',
+        consent: baseConsent,
+        argv: ['plan', 'task', 'update'],
+      })
+    ).rejects.toMatchObject({ code: 'invalid_input' });
+    // The registered read and preview methods bind identity at the host boundary:
+    // an unsafe run component, an unknown readback kind, a path-shaped reference
+    // field, and any extra input surface are all refused before the adapter runs.
+    await expect(
+      harness.callRpc('readResult', {
+        projectId: 'project-1',
+        sourceId: 'source-1',
+        runId: '../etc/passwd',
+        kind: 'competition',
+      })
+    ).rejects.toMatchObject({ code: 'invalid_input' });
+    await expect(
+      harness.callRpc('readResult', {
+        projectId: 'project-1',
+        sourceId: 'source-1',
+        runId: 'run-1',
+        kind: 'anything',
+      })
+    ).rejects.toMatchObject({ code: 'invalid_input' });
+    await expect(
+      harness.callRpc('previewPatch', {
+        projectId: 'project-1',
+        sourceId: 'source-1',
+        runId: 'run-1',
+        kind: 'competition',
+        reference: { kind: 'patch', value: 'artifact.patch', path: '/etc/passwd' },
+      })
+    ).rejects.toMatchObject({ code: 'invalid_input' });
+    await expect(
+      harness.callRpc('setupStatus', {
+        projectId: 'project-1',
+        sourceId: 'source-1',
+        command: 'poetic provider setup',
+      })
+    ).rejects.toMatchObject({ code: 'invalid_input' });
+    await expect(harness.callRpc('listProjects', null)).resolves.toEqual({
+      projects: [
+        {
+          id: 'project-1',
+          name: 'Poetic',
+          sources: [{ id: 'source-1', path: '/tmp/poetic' }],
+        },
+      ],
+    });
+    expect(harness.sdk.callsTo('system.config')).toHaveLength(1);
+    expect(harness.sdk.callsTo('projects.list')).toEqual([[{ includePersonal: true }]]);
+  });
+});