@a5c-ai/krate 5.0.1-staging.3a341c33c

package/tests/agent-trigger-controller.test.js

@@ -0,0 +1,211 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { createAgentTriggerController, createResource } from '../src/index.js';
+
+function makeTriggerRule(name, spec = {}) {
+  return createResource('AgentTriggerRule', { name, namespace: 'krate-org-default' }, {
+    organizationRef: 'default',
+    sources: ['ci-failure'],
+    agentStack: 'debug-stack',
+    taskKind: 'diagnostic',
+    ...spec
+  });
+}
+
+function makeEvent(overrides = {}) {
+  return {
+    type: 'ci-failure',
+    repository: 'myapp',
+    ref: 'main',
+    actor: 'alice',
+    source: { kind: 'Pipeline', name: 'pipeline-123' },
+    ...overrides
+  };
+}
+
+function makeExecution(ruleName, eventUid, phase = 'Dispatched') {
+  const exec = createResource('AgentTriggerExecution', { name: `exec-${ruleName}-1`, namespace: 'krate-org-default' }, {
+    organizationRef: 'default',
+    triggerRule: ruleName,
+    sourceEvent: eventUid,
+    decision: phase
+  });
+  exec.status = { phase };
+  return exec;
+}
+
+// 1. matchRule: event type matches
+test('matchRule: event type matches rule sources', () => {
+  const controller = createAgentTriggerController();
+  const rule = makeTriggerRule('rule-1', { sources: ['ci-failure'] });
+  const event = makeEvent({ type: 'ci-failure' });
+
+  const result = controller.matchRule(rule, event);
+
+  assert.equal(result.matches, true);
+  assert.equal(result.reason, 'All conditions met');
+});
+
+// 2. matchRule: event type doesn't match
+test('matchRule: event type does not match rule sources', () => {
+  const controller = createAgentTriggerController();
+  const rule = makeTriggerRule('rule-2', { sources: ['ci-failure'] });
+  const event = makeEvent({ type: 'webhook' });
+
+  const result = controller.matchRule(rule, event);
+
+  assert.equal(result.matches, false);
+  assert.ok(result.reason.includes("'webhook'"), 'Reason should mention the event type');
+  assert.ok(result.reason.includes('ci-failure'), 'Reason should mention the expected source');
+});
+
+// 3. matchRule: repository scope match
+test('matchRule: repository scope matches', () => {
+  const controller = createAgentTriggerController();
+  const rule = makeTriggerRule('rule-3', { sources: ['ci-failure'], repository: 'myapp' });
+  const event = makeEvent({ type: 'ci-failure', repository: 'myapp' });
+
+  const result = controller.matchRule(rule, event);
+
+  assert.equal(result.matches, true);
+  assert.equal(result.reason, 'All conditions met');
+});
+
+// 4. matchRule: repository scope mismatch
+test('matchRule: repository scope mismatch', () => {
+  const controller = createAgentTriggerController();
+  const rule = makeTriggerRule('rule-4', { sources: ['ci-failure'], repository: 'myapp' });
+  const event = makeEvent({ type: 'ci-failure', repository: 'other' });
+
+  const result = controller.matchRule(rule, event);
+
+  assert.equal(result.matches, false);
+  assert.ok(result.reason.includes("'other'"), 'Reason should mention the event repository');
+  assert.ok(result.reason.includes("'myapp'"), 'Reason should mention the rule scope');
+});
+
+// 5. matchRule: actor filter
+test('matchRule: actor not in allowedActors', () => {
+  const controller = createAgentTriggerController();
+  const rule = makeTriggerRule('rule-5', { sources: ['ci-failure'], allowedActors: ['alice'] });
+  const event = makeEvent({ type: 'ci-failure', actor: 'bob' });
+
+  const result = controller.matchRule(rule, event);
+
+  assert.equal(result.matches, false);
+  assert.ok(result.reason.includes("'bob'"), 'Reason should mention the rejected actor');
+});
+
+// 6. evaluateEvent: deduplication
+test('evaluateEvent: marks duplicate when existing execution matches', () => {
+  const controller = createAgentTriggerController();
+  const rule = makeTriggerRule('rule-dedup');
+  const event = makeEvent();
+  const eventUid = `${event.type}:${event.source.kind}:${event.source.name}`;
+  const existingExecution = makeExecution('rule-dedup', eventUid, 'Dispatched');
+
+  const resources = {
+    AgentTriggerRule: [rule],
+    AgentTriggerExecution: [existingExecution]
+  };
+
+  const evaluations = controller.evaluateEvent({ event, resources });
+
+  assert.equal(evaluations.length, 1);
+  assert.equal(evaluations[0].matches, true);
+  assert.equal(evaluations[0].isDuplicate, true);
+});
+
+// 7. processEvent: dispatches matching rules
+test('processEvent: dispatches matching rules via dispatch controller', async () => {
+  let dispatchCalled = false;
+  const mockDispatchController = {
+    async createManualDispatch(input) {
+      dispatchCalled = true;
+      const run = createResource('AgentDispatchRun', { name: `dispatch-${Date.now()}`, namespace: input.namespace }, {
+        organizationRef: input.organizationRef,
+        repository: input.repository,
+        sourceRefs: input.sourceRefs,
+        agentStack: input.agentStack,
+        taskKind: input.taskKind
+      });
+      run.status = { phase: 'Queued' };
+      return { error: false, run };
+    }
+  };
+  const controller = createAgentTriggerController({ dispatchController: mockDispatchController });
+  const rule = makeTriggerRule('rule-dispatch');
+  const event = makeEvent();
+  const resources = { AgentTriggerRule: [rule], AgentTriggerExecution: [] };
+
+  const result = await controller.processEvent({ event, resources, namespace: 'krate-org-default', organizationRef: 'default' });
+
+  assert.equal(dispatchCalled, true, 'Dispatch controller should be called');
+  assert.equal(result.dispatched, 1);
+  assert.equal(result.skipped, 0);
+  assert.equal(result.processed, 1);
+  assert.equal(result.executions.length, 1);
+  assert.equal(result.executions[0].status.phase, 'Dispatched');
+  assert.ok(result.executions[0].status.dispatchRunRef, 'Execution should reference the dispatch run');
+});
+
+// 8. processEvent: skips non-matching
+test('processEvent: skips non-matching rules', async () => {
+  const controller = createAgentTriggerController();
+  const rule = makeTriggerRule('rule-skip', { sources: ['ci-failure'] });
+  const event = makeEvent({ type: 'webhook' });
+  const resources = { AgentTriggerRule: [rule], AgentTriggerExecution: [] };
+
+  const result = await controller.processEvent({ event, resources });
+
+  assert.equal(result.dispatched, 0);
+  assert.equal(result.skipped, 1);
+  assert.equal(result.processed, 1);
+  assert.equal(result.executions[0].status.phase, 'Skipped');
+});
+
+// 9. processEvent: multiple rules match same event
+test('processEvent: multiple rules match same event', async () => {
+  let dispatchCount = 0;
+  const mockDispatchController = {
+    async createManualDispatch(input) {
+      dispatchCount++;
+      const run = createResource('AgentDispatchRun', { name: `dispatch-${Date.now()}-${dispatchCount}`, namespace: input.namespace }, {
+        organizationRef: input.organizationRef,
+        repository: input.repository,
+        sourceRefs: input.sourceRefs,
+        agentStack: input.agentStack,
+        taskKind: input.taskKind
+      });
+      run.status = { phase: 'Queued' };
+      return { error: false, run };
+    }
+  };
+  const controller = createAgentTriggerController({ dispatchController: mockDispatchController });
+  const rule1 = makeTriggerRule('rule-multi-1', { sources: ['ci-failure'], agentStack: 'stack-a' });
+  const rule2 = makeTriggerRule('rule-multi-2', { sources: ['ci-failure'], agentStack: 'stack-b' });
+  const event = makeEvent();
+  const resources = { AgentTriggerRule: [rule1, rule2], AgentTriggerExecution: [] };
+
+  const result = await controller.processEvent({ event, resources, namespace: 'krate-org-default', organizationRef: 'default' });
+
+  assert.equal(dispatchCount, 2, 'Dispatch should be called twice');
+  assert.equal(result.dispatched, 2);
+  assert.equal(result.skipped, 0);
+  assert.equal(result.processed, 2);
+  assert.equal(result.executions.length, 2);
+});
+
+// 10. processEvent: no rules
+test('processEvent: empty rules array', async () => {
+  const controller = createAgentTriggerController();
+  const event = makeEvent();
+  const resources = { AgentTriggerRule: [], AgentTriggerExecution: [] };
+
+  const result = await controller.processEvent({ event, resources });
+
+  assert.equal(result.processed, 0);
+  assert.equal(result.dispatched, 0);
+  assert.equal(result.skipped, 0);
+  assert.equal(result.executions.length, 0);
+});

package/tests/agent-workspace-controller.test.js

@@ -0,0 +1,215 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { createAgentWorkspaceController, createResource } from '../src/index.js';
+
+function makeWorkspace(name, repository, ownership, phase = 'Active', extra = {}) {
+  const workspace = createResource('AgentWorkspace', { name, namespace: 'krate-org-default' }, {
+    organizationRef: 'default',
+    repository,
+    workspacePath: `/workspaces/${repository}/main-${Date.now()}`,
+    ownership,
+    ...extra
+  });
+  workspace.status = { phase, createdAt: new Date().toISOString(), boundSessions: [], ...extra.status };
+  return workspace;
+}
+
+function makeRuntime(name, workspaceRef, status = 'provisioning') {
+  const runtime = createResource('AgentWorkspaceRuntime', { name, namespace: 'krate-org-default' }, {
+    organizationRef: 'default',
+    workspaceRef,
+    status
+  });
+  runtime.status = { phase: 'Provisioning', createdAt: new Date().toISOString() };
+  return runtime;
+}
+
+test('provisionWorkspace creates AgentWorkspace + AgentWorkspaceRuntime', () => {
+  const controller = createAgentWorkspaceController();
+  const result = controller.provisionWorkspace({
+    repository: 'my-repo',
+    ref: 'abc123',
+    branch: 'feature-1',
+    dispatchRun: 'run-1',
+    namespace: 'krate-org-default',
+    organizationRef: 'default'
+  });
+
+  assert.equal(result.error, false, 'Should succeed');
+  assert.ok(result.workspace, 'Should return a workspace resource');
+  assert.equal(result.workspace.kind, 'AgentWorkspace');
+  assert.equal(result.workspace.spec.repository, 'my-repo');
+  assert.equal(result.workspace.spec.ownership, 'run-1');
+  assert.ok(result.workspace.spec.workspacePath.includes('my-repo'), 'workspacePath should contain repository');
+  assert.ok(result.workspace.spec.workspacePath.includes('feature-1'), 'workspacePath should contain branch');
+  assert.equal(result.workspace.status.phase, 'Active');
+  assert.ok(Array.isArray(result.workspace.status.boundSessions), 'boundSessions should be an array');
+
+  assert.ok(result.runtime, 'Should return a runtime resource');
+  assert.equal(result.runtime.kind, 'AgentWorkspaceRuntime');
+  assert.equal(result.runtime.spec.workspaceRef, result.workspace.metadata.name);
+  assert.equal(result.runtime.spec.status, 'provisioning');
+  assert.equal(result.runtime.status.phase, 'Provisioning');
+});
+
+test('archiveWorkspace sets phase=Archived', () => {
+  const controller = createAgentWorkspaceController();
+  const existing = makeWorkspace('ws-1', 'my-repo', 'run-1', 'Active');
+  const result = controller.archiveWorkspace({
+    workspaceName: 'ws-1',
+    reason: 'Run completed',
+    resources: { AgentWorkspace: [existing] }
+  });
+
+  assert.equal(result.error, false, 'Should succeed');
+  assert.equal(result.workspace.status.phase, 'Archived');
+  assert.ok(result.workspace.status.archivedAt, 'Should have archivedAt timestamp');
+  assert.equal(result.workspace.status.archiveReason, 'Run completed');
+});
+
+test('recoverWorkspace sets phase=Active', () => {
+  const controller = createAgentWorkspaceController();
+  const archived = makeWorkspace('ws-2', 'my-repo', 'run-1', 'Archived', {
+    status: { archivedAt: new Date().toISOString(), archiveReason: 'Cleanup' }
+  });
+  const result = controller.recoverWorkspace({
+    workspaceName: 'ws-2',
+    resources: { AgentWorkspace: [archived] }
+  });
+
+  assert.equal(result.error, false, 'Should succeed');
+  assert.equal(result.workspace.status.phase, 'Active');
+  assert.equal(result.workspace.status.archivedAt, undefined, 'archivedAt should be cleared');
+  assert.equal(result.workspace.status.archiveReason, undefined, 'archiveReason should be cleared');
+});
+
+test('bindSession adds session to boundSessions', () => {
+  const controller = createAgentWorkspaceController();
+  const existing = makeWorkspace('ws-3', 'my-repo', 'run-2', 'Active');
+  const result = controller.bindSession({
+    workspaceName: 'ws-3',
+    sessionRef: 'session-1',
+    agent: 'code-agent',
+    namespace: 'krate-org-default',
+    organizationRef: 'default',
+    resources: { AgentWorkspace: [existing] }
+  });
+
+  assert.equal(result.error, false, 'Should succeed');
+  assert.ok(result.workspace, 'Should return updated workspace');
+  assert.equal(result.workspace.status.boundSessions.length, 1, 'Should have one bound session');
+  assert.equal(result.workspace.status.boundSessions[0].sessionRef, 'session-1');
+  assert.equal(result.workspace.status.boundSessions[0].agent, 'code-agent');
+  assert.ok(result.workspace.status.boundSessions[0].boundAt, 'Should have boundAt timestamp');
+});
+
+test('linkWorkItem creates WorkItemWorkspaceLink', () => {
+  const controller = createAgentWorkspaceController();
+  const result = controller.linkWorkItem({
+    workspaceName: 'ws-4',
+    workItemRef: 'issue-42',
+    workItemKind: 'Issue',
+    namespace: 'krate-org-default',
+    organizationRef: 'default'
+  });
+
+  assert.equal(result.error, false, 'Should succeed');
+  assert.ok(result.link, 'Should return a link resource');
+  assert.equal(result.link.kind, 'WorkItemWorkspaceLink');
+  assert.equal(result.link.spec.workItemRef, 'issue-42');
+  assert.equal(result.link.spec.workItemKind, 'Issue');
+  assert.equal(result.link.spec.workspace, 'ws-4');
+  assert.equal(result.link.spec.organizationRef, 'default');
+});
+
+test('linkWorkItemToSession creates WorkItemSessionLink', () => {
+  const controller = createAgentWorkspaceController();
+  const result = controller.linkWorkItemToSession({
+    workItemRef: 'pr-10',
+    workItemKind: 'PullRequest',
+    sessionRef: 'session-5',
+    namespace: 'krate-org-default',
+    organizationRef: 'default'
+  });
+
+  assert.equal(result.error, false, 'Should succeed');
+  assert.ok(result.link, 'Should return a link resource');
+  assert.equal(result.link.kind, 'WorkItemSessionLink');
+  assert.equal(result.link.spec.workItemRef, 'pr-10');
+  assert.equal(result.link.spec.workItemKind, 'PullRequest');
+  assert.equal(result.link.spec.agentSession, 'session-5');
+  assert.equal(result.link.spec.organizationRef, 'default');
+});
+
+test('getWorkspaceStatus returns full bindings', () => {
+  const controller = createAgentWorkspaceController();
+  const ws = makeWorkspace('ws-5', 'my-repo', 'run-3', 'Active', {
+    status: { boundSessions: [{ sessionRef: 'session-10', boundAt: new Date().toISOString() }] }
+  });
+  const rt = makeRuntime('rt-ws-5', 'ws-5', 'provisioning');
+  const link = createResource('WorkItemWorkspaceLink', { name: 'link-1', namespace: 'krate-org-default' }, {
+    organizationRef: 'default',
+    workItemRef: 'issue-99',
+    workspace: 'ws-5'
+  });
+
+  const result = controller.getWorkspaceStatus({
+    workspaceName: 'ws-5',
+    resources: {
+      AgentWorkspace: [ws],
+      AgentWorkspaceRuntime: [rt],
+      AgentSession: [],
+      WorkItemWorkspaceLink: [link]
+    }
+  });
+
+  assert.equal(result.error, false, 'Should succeed');
+  assert.ok(result.workspace, 'Should return workspace');
+  assert.equal(result.workspace.metadata.name, 'ws-5');
+  assert.ok(result.runtime, 'Should return runtime');
+  assert.equal(result.runtime.spec.workspaceRef, 'ws-5');
+  assert.equal(result.sessions.length, 1, 'Should return bound sessions');
+  assert.equal(result.workItems.length, 1, 'Should return linked work items');
+  assert.equal(result.workItems[0].spec.workItemRef, 'issue-99');
+});
+
+test('listWorkspacesForRepo filters by repository', () => {
+  const controller = createAgentWorkspaceController();
+  const ws1 = makeWorkspace('ws-a', 'repo-alpha', 'run-a');
+  const ws2 = makeWorkspace('ws-b', 'repo-beta', 'run-b');
+  const ws3 = makeWorkspace('ws-c', 'repo-alpha', 'run-c');
+
+  const result = controller.listWorkspacesForRepo({
+    repository: 'repo-alpha',
+    resources: { AgentWorkspace: [ws1, ws2, ws3] }
+  });
+
+  assert.equal(result.length, 2, 'Should return workspaces for repo-alpha only');
+  assert.ok(result.every((w) => w.spec.repository === 'repo-alpha'), 'All should belong to repo-alpha');
+});
+
+test('archiveWorkspace on nonexistent returns error', () => {
+  const controller = createAgentWorkspaceController();
+  const result = controller.archiveWorkspace({
+    workspaceName: 'ws-nonexistent',
+    reason: 'Cleanup',
+    resources: { AgentWorkspace: [] }
+  });
+
+  assert.equal(result.error, true, 'Should fail');
+  assert.equal(result.reason, 'not-found');
+  assert.ok(result.message.includes('ws-nonexistent'), 'Message should mention the workspace name');
+});
+
+test('recoverWorkspace on non-archived returns error', () => {
+  const controller = createAgentWorkspaceController();
+  const active = makeWorkspace('ws-active', 'my-repo', 'run-x', 'Active');
+  const result = controller.recoverWorkspace({
+    workspaceName: 'ws-active',
+    resources: { AgentWorkspace: [active] }
+  });
+
+  assert.equal(result.error, true, 'Should fail');
+  assert.equal(result.reason, 'not-archived');
+  assert.ok(result.message.includes('not archived'), 'Message should indicate not archived');
+});