@a5c-ai/krate 5.0.1-staging.04a3db697

package/tests/agent-transport-binding-controller.test.js

@@ -0,0 +1,294 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+  createAgentTransportBindingController,
+  validateAgentTransportBinding,
+  createResource,
+  AGENT_TRANSPORT_BINDING_CONTROLLER_BOUNDARY
+} from '../src/index.js';
+
+// ---------------------------------------------------------------------------
+// Acceptance criteria: Slice 1.2b — Agent Transport Binding Controller
+//
+// An AgentTransportBinding connects an adapter to a specific endpoint.
+// It specifies binding name, adapterRef, connection endpoint, protocol,
+// health status tracking, and a reconnect policy.
+//
+// All tests in this file are expected to FAIL until the controller is
+// implemented and exported from src/index.js.
+// ---------------------------------------------------------------------------
+
+const VALID_PROTOCOLS = ['stdio', 'http', 'websocket', 'unix'];
+
+function makeBinding(name, overrides = {}) {
+  return createResource('AgentTransportBinding', { name, namespace: 'krate-org-default' }, {
+    organizationRef: 'default',
+    adapterRef: 'claude-code-adapter',
+    endpoint: 'http://localhost:8080',
+    protocol: 'http',
+    ...overrides
+  });
+}
+
+// ---------------------------------------------------------------------------
+// 1. Factory and shape
+// ---------------------------------------------------------------------------
+
+test('createAgentTransportBindingController returns a controller with validate method', () => {
+  const controller = createAgentTransportBindingController();
+  assert.ok(controller, 'controller must be truthy');
+  assert.equal(typeof controller.validate, 'function', 'controller must expose a validate method');
+  assert.equal(controller.role, 'agent-transport-binding-controller', 'controller must declare its role');
+});
+
+// ---------------------------------------------------------------------------
+// 2. validate — happy path
+// ---------------------------------------------------------------------------
+
+test('validate accepts valid binding with name, adapterRef, endpoint, protocol', () => {
+  const controller = createAgentTransportBindingController();
+  const binding = makeBinding('my-transport-binding');
+  const result = controller.validate(binding);
+
+  assert.equal(result.valid, true, 'valid binding must pass validation');
+  assert.ok(Array.isArray(result.errors), 'result must contain an errors array');
+  assert.equal(result.errors.length, 0, 'errors array must be empty for a valid binding');
+});
+
+// ---------------------------------------------------------------------------
+// 3. validate — missing name
+// ---------------------------------------------------------------------------
+
+test('validate rejects missing name', () => {
+  const controller = createAgentTransportBindingController();
+  const binding = {
+    apiVersion: 'krate.a5c.ai/v1alpha1',
+    kind: 'AgentTransportBinding',
+    metadata: { namespace: 'krate-org-default', labels: {}, annotations: {} },
+    spec: {
+      organizationRef: 'default',
+      adapterRef: 'claude-code-adapter',
+      endpoint: 'http://localhost:8080',
+      protocol: 'http'
+    },
+    status: {}
+  };
+  const result = controller.validate(binding);
+
+  assert.equal(result.valid, false, 'binding without name must fail validation');
+  assert.ok(result.errors.length > 0, 'errors array must not be empty');
+  assert.ok(
+    result.errors.some((e) => /name/i.test(e)),
+    'at least one error must mention "name"'
+  );
+});
+
+// ---------------------------------------------------------------------------
+// 4. validate — missing adapterRef
+// ---------------------------------------------------------------------------
+
+test('validate rejects missing adapterRef', () => {
+  const controller = createAgentTransportBindingController();
+  const binding = makeBinding('no-adapter-binding');
+  delete binding.spec.adapterRef;
+  const result = controller.validate(binding);
+
+  assert.equal(result.valid, false, 'binding without adapterRef must fail validation');
+  assert.ok(result.errors.length > 0, 'errors array must not be empty');
+  assert.ok(
+    result.errors.some((e) => /adapterRef/i.test(e)),
+    'at least one error must mention "adapterRef"'
+  );
+});
+
+// ---------------------------------------------------------------------------
+// 5. validate — missing endpoint
+// ---------------------------------------------------------------------------
+
+test('validate rejects missing endpoint', () => {
+  const controller = createAgentTransportBindingController();
+  const binding = makeBinding('no-endpoint-binding');
+  delete binding.spec.endpoint;
+  const result = controller.validate(binding);
+
+  assert.equal(result.valid, false, 'binding without endpoint must fail validation');
+  assert.ok(result.errors.length > 0, 'errors array must not be empty');
+  assert.ok(
+    result.errors.some((e) => /endpoint/i.test(e)),
+    'at least one error must mention "endpoint"'
+  );
+});
+
+// ---------------------------------------------------------------------------
+// 6. validate — invalid protocol
+// ---------------------------------------------------------------------------
+
+test('validate rejects invalid protocol (not in stdio/http/websocket/unix)', () => {
+  const controller = createAgentTransportBindingController();
+  const binding = makeBinding('bad-protocol-binding', { protocol: 'grpc' });
+  const result = controller.validate(binding);
+
+  assert.equal(result.valid, false, 'binding with unsupported protocol must fail validation');
+  assert.ok(result.errors.length > 0, 'errors array must not be empty');
+  assert.ok(
+    result.errors.some((e) => /protocol/i.test(e)),
+    'at least one error must mention "protocol"'
+  );
+  assert.ok(
+    result.errors.some((e) => VALID_PROTOCOLS.some((p) => e.includes(p))),
+    'error must enumerate valid protocols'
+  );
+});
+
+// ---------------------------------------------------------------------------
+// 7. getConnectionStatus — default 'unknown' for new binding
+// ---------------------------------------------------------------------------
+
+test('getConnectionStatus returns default "unknown" for new binding', () => {
+  const controller = createAgentTransportBindingController();
+  const binding = makeBinding('new-binding');
+  const status = controller.getConnectionStatus(binding);
+
+  assert.ok(status, 'getConnectionStatus must return a value');
+  assert.equal(status.connectionStatus, 'unknown', 'default connection status must be "unknown"');
+  assert.equal(status.bindingName, binding.metadata.name, 'result must carry the binding name');
+});
+
+// ---------------------------------------------------------------------------
+// 8. getReconnectPolicy — returns policy from spec with defaults
+// ---------------------------------------------------------------------------
+
+test('getReconnectPolicy returns policy from spec with defaults', () => {
+  const controller = createAgentTransportBindingController();
+  const binding = makeBinding('policy-binding', {
+    reconnectPolicy: {
+      maxRetries: 5,
+      backoffMs: 500,
+      maxBackoffMs: 30000
+    }
+  });
+  const policy = controller.getReconnectPolicy(binding);
+
+  assert.ok(policy, 'getReconnectPolicy must return a value');
+  assert.equal(policy.maxRetries, 5, 'maxRetries must match spec');
+  assert.equal(policy.backoffMs, 500, 'backoffMs must match spec');
+  assert.equal(policy.maxBackoffMs, 30000, 'maxBackoffMs must match spec');
+});
+
+// ---------------------------------------------------------------------------
+// 9. getReconnectPolicy — returns defaults when no policy in spec
+// ---------------------------------------------------------------------------
+
+test('getReconnectPolicy returns defaults when no policy in spec', () => {
+  const controller = createAgentTransportBindingController();
+  const binding = makeBinding('no-policy-binding');
+  // no reconnectPolicy in spec
+  const policy = controller.getReconnectPolicy(binding);
+
+  assert.ok(policy, 'getReconnectPolicy must return a value');
+  assert.ok(typeof policy.maxRetries === 'number', 'maxRetries must default to a number');
+  assert.ok(typeof policy.backoffMs === 'number', 'backoffMs must default to a number');
+  assert.ok(typeof policy.maxBackoffMs === 'number', 'maxBackoffMs must default to a number');
+  assert.ok(policy.maxRetries >= 0, 'maxRetries default must be non-negative');
+  assert.ok(policy.backoffMs >= 0, 'backoffMs default must be non-negative');
+  assert.ok(policy.maxBackoffMs >= policy.backoffMs, 'maxBackoffMs must be >= backoffMs');
+});
+
+// ---------------------------------------------------------------------------
+// 10. validate — rejects null resource
+// ---------------------------------------------------------------------------
+
+test('validate rejects null resource', () => {
+  const controller = createAgentTransportBindingController();
+  const result = controller.validate(null);
+
+  assert.equal(result.valid, false, 'null resource must fail validation');
+  assert.ok(result.errors.length > 0, 'errors array must not be empty');
+  assert.ok(
+    result.errors.some((e) => /null|undefined/i.test(e)),
+    'error must mention null or undefined'
+  );
+});
+
+// ---------------------------------------------------------------------------
+// 11. BOUNDARY object exported with correct role
+// ---------------------------------------------------------------------------
+
+test('AGENT_TRANSPORT_BINDING_CONTROLLER_BOUNDARY is exported and has correct role', () => {
+  assert.ok(AGENT_TRANSPORT_BINDING_CONTROLLER_BOUNDARY, 'BOUNDARY must be exported');
+  assert.equal(
+    AGENT_TRANSPORT_BINDING_CONTROLLER_BOUNDARY.role,
+    'agent-transport-binding-controller',
+    'BOUNDARY role must be "agent-transport-binding-controller"'
+  );
+  assert.ok(
+    Array.isArray(AGENT_TRANSPORT_BINDING_CONTROLLER_BOUNDARY.owns),
+    'BOUNDARY must declare owned concerns'
+  );
+});
+
+// ---------------------------------------------------------------------------
+// 12. validate — all valid protocols are accepted
+// ---------------------------------------------------------------------------
+
+test('validate accepts each valid protocol (stdio, http, websocket, unix)', () => {
+  const controller = createAgentTransportBindingController();
+  for (const protocol of VALID_PROTOCOLS) {
+    const binding = makeBinding(`binding-${protocol}`, { protocol });
+    const result = controller.validate(binding);
+    assert.equal(result.valid, true, `protocol "${protocol}" must be accepted`);
+    assert.equal(result.errors.length, 0, `no errors expected for protocol "${protocol}"`);
+  }
+});
+
+// ---------------------------------------------------------------------------
+// 13. getConnectionStatus — reads from status.connectionStatus when present
+// ---------------------------------------------------------------------------
+
+test('getConnectionStatus reads connectionStatus from resource status field when present', () => {
+  const controller = createAgentTransportBindingController();
+  const binding = makeBinding('connected-binding');
+  binding.status = { connectionStatus: 'connected' };
+  const status = controller.getConnectionStatus(binding);
+
+  assert.equal(status.connectionStatus, 'connected', 'must reflect status from resource status field');
+});
+
+// ---------------------------------------------------------------------------
+// 14. validate accumulates errors for multiple missing fields
+// ---------------------------------------------------------------------------
+
+test('validate accumulates errors when both adapterRef and endpoint are missing', () => {
+  const controller = createAgentTransportBindingController();
+  const binding = makeBinding('double-missing-binding');
+  delete binding.spec.adapterRef;
+  delete binding.spec.endpoint;
+  const result = controller.validate(binding);
+
+  assert.equal(result.valid, false, 'binding with multiple missing fields must fail validation');
+  assert.ok(
+    result.errors.some((e) => /adapterRef/i.test(e)),
+    'errors must include adapterRef error'
+  );
+  assert.ok(
+    result.errors.some((e) => /endpoint/i.test(e)),
+    'errors must include endpoint error'
+  );
+  assert.ok(result.errors.length >= 2, 'must accumulate at least two errors');
+});
+
+// ---------------------------------------------------------------------------
+// 15. validateAgentTransportBinding standalone export
+// ---------------------------------------------------------------------------
+
+test('validateAgentTransportBinding is exported and validates correctly', () => {
+  assert.equal(typeof validateAgentTransportBinding, 'function', 'validateAgentTransportBinding must be a named export');
+
+  const binding = makeBinding('standalone-validate-binding');
+  const result = validateAgentTransportBinding(binding);
+
+  assert.ok(result, 'validateAgentTransportBinding must return a result');
+  assert.ok('valid' in result, 'result must have a valid property');
+  assert.ok(Array.isArray(result.errors), 'result must have an errors array');
+  assert.equal(result.valid, true, 'a fully-specified binding must pass standalone validation');
+});

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);
+});