@a5c-ai/kradle 5.0.1-staging.3abdf9534c25

package/tests/e2e/lifecycle.test.js

@@ -0,0 +1,120 @@
+import test from 'node:test';
+
+import assert from 'node:assert/strict';
+
+import { execFileSync } from 'node:child_process';
+
+import { existsSync, readFileSync } from 'node:fs';
+
+import { buildMinikubePlan } from '../../scripts/setup-minikube.mjs';
+
+
+
+const requiredChartFiles = [
+
+  '../charts/Chart.yaml',
+
+  '../charts/values.yaml',
+
+  '../charts/crds/repositories.yaml',
+
+  '../charts/crds/aggregated-resources.yaml',
+
+  '../charts/templates/apiservice.yaml',
+
+  '../charts/templates/deployments.yaml',
+
+  '../charts/templates/rbac.yaml',
+
+  '../charts/templates/services.yaml',
+
+
+  '../charts/templates/networkpolicy.yaml',
+  '../charts/templates/gitea.yaml',
+  '../charts/templates/argocd-application.yaml',
+
+  'examples/minikube-demo.yaml'
+
+];
+
+
+
+test('chart package contains the MVP Kubernetes install surface', () => {
+
+  for (const file of requiredChartFiles) assert.equal(existsSync(file), true, `${file} exists`);
+
+  const chart = requiredChartFiles.map((file) => readFileSync(file, 'utf8')).join('\n');
+  const values = readFileSync('../charts/values.yaml', 'utf8');
+
+  for (const kind of ['CustomResourceDefinition', 'Deployment', 'Service', 'ServiceAccount', 'ClusterRole', 'NetworkPolicy', 'PersistentVolumeClaim']) assert.ok(chart.includes(`kind: ${kind}`), `chart includes ${kind}`);
+
+  for (const resource of ['Organization', 'Repository', 'SSHKey', 'RepositoryPermission', 'BranchProtection', 'RefPolicy', 'PullRequest', 'Issue', 'Review', 'Pipeline', 'Job', 'RunnerPool', 'WebhookSubscription', 'WebhookDelivery', 'View', 'Selector']) assert.ok(chart.includes(`kind: ${resource}`), `package covers ${resource}`);
+  assert.ok(chart.includes('kind: Pipeline'), 'package includes demo Pipeline workflow');
+  assert.ok(chart.includes('kind: Application'), 'package includes Argo CD Application');
+  assert.ok(chart.includes('kradle-kubevela'), 'package installs KubeVela through Argo CD');
+  assert.ok(chart.includes('core.oam.dev'), 'Kradle service account can manage delivery resources');
+  assert.ok(chart.includes('create') && chart.includes('delete'), 'Kradle service account can compose and remove delivery resources');
+  assert.ok(chart.includes('vela-core'), 'package references upstream KubeVela vela-core chart');
+  assert.ok(chart.includes('apiService') && chart.includes('enabled: false'), 'APIService registration is optional for CRD-backed local installs');
+  assert.ok(chart.includes('gitea/gitea'), 'package includes Gitea backend image');
+  assert.ok(chart.includes('readinessProbe'), 'workloads expose readiness probes for live installs');
+  assert.ok(chart.includes('serviceAccountName'), 'workloads run with the Kradle service account');
+  assert.ok(chart.includes('customresourcedefinitions'), 'service account can discover installed Kradle CRDs');
+  assert.ok(chart.includes('kradle.webImage'), 'web deployment uses the web container image');
+  assert.ok(chart.includes('sshkeys.kradle.a5c.ai'), 'package includes SSH key reconciliation resources');
+  assert.ok(chart.includes('repositorypermissions.kradle.a5c.ai'), 'package includes Gitea permission reconciliation resources');
+  assert.ok(chart.includes('revoked'), 'package access CRDs allow revocation state');
+  assert.ok(chart.includes('KRADLE_CONTROLLER_URL'), 'web deployment points at the in-cluster controller API');
+  assert.ok(values.includes('port: 80'), 'controller API service exposes an HTTP service port for in-cluster web fetches');
+  assert.ok(!values.includes('port: 443'), 'controller API does not expose plain HTTP through a TLS-looking service port');
+  assert.ok(chart.includes('containerPort: 2222'), 'rootless Gitea SSH service targets port 2222');
+  assert.ok(chart.includes('kradle.fullname') && chart.includes('gitea-http'), 'Gitea and Argo CD URLs derive the release-scoped service name');
+  assert.ok(chart.includes('kradle.a5c.ai/gitops-engine: argocd'), 'package labels Argo CD GitOps engine');
+  assert.ok(!chart.includes('`n'), 'package values use real YAML newlines');
+  assert.ok(chart.includes('.Values.argocd.syncPolicy.prune'), 'Argo CD template consumes syncPolicy.prune');
+  assert.ok(chart.includes('.Values.argocd.syncPolicy.selfHeal'), 'Argo CD template consumes syncPolicy.selfHeal');
+  assert.ok(chart.includes('- CreateNamespace=true'), 'values expose Argo CD CreateNamespace sync option');
+  for (const valueTerm of ['externalDependencies', 'objectStorage', 'oidc', 'gatekeeper', 'autoscaling', 'targetCPUUtilizationPercentage', 'gitea', 'argocd', 'repoURL', 'syncPolicy']) assert.ok(chart.includes(valueTerm), `values expose ${valueTerm}`);
+});
+
+
+
+test('minikube setup dry-run exposes deterministic local install commands', () => {
+
+  const plan = buildMinikubePlan({ apply: false, json: true, profile: 'kradle-test', namespace: 'kradle-system', release: 'kradle', driver: 'docker', chart: '../charts' });
+
+  const commands = plan.commands.map(([cmd, args]) => [cmd, ...args].join(' '));
+
+  assert.equal(plan.mode, 'dry-run');
+
+  assert.ok(commands.some((command) => command.startsWith('minikube start -p kradle-test')));
+
+  assert.ok(commands.includes('helm lint ../charts'));
+
+  assert.ok(commands.some((command) => command.includes('helm upgrade --install kradle ../charts')));
+
+  assert.ok(commands.includes('kubectl apply -n kradle-system -f examples/minikube-demo.yaml'));
+
+  assert.ok(commands.includes('node scripts/smoke.mjs'));
+
+});
+
+
+
+test('setup:minikube --dry-run --json is machine-readable', () => {
+
+  const output = execFileSync(process.execPath, ['scripts/setup-minikube.mjs', '--dry-run', '--json', '--profile=kradle-test'], { encoding: 'utf8' });
+
+  const parsed = JSON.parse(output);
+
+  assert.equal(parsed.mode, 'dry-run');
+
+  assert.ok(parsed.requiredTools.includes('minikube'));
+
+  assert.ok(parsed.commands.some((command) => command.includes('helm lint ../charts')));
+
+});
+
+
+
+

package/tests/event-bus-integration.test.js

@@ -0,0 +1,355 @@
+/**
+ * Event bus integration tests
+ *
+ * Exercises the event bus pub/sub mechanism with multiple subscribers,
+ * emitResourceChange field validation, unsubscribe isolation, and the
+ * globalEventBus singleton.
+ */
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { createEventBus, globalEventBus, createMemoryEventTransport, createNatsJetStreamEventTransport } from '../src/event-bus.js';
+
+// ---------------------------------------------------------------------------
+// globalEventBus.emit notifies all subscribers
+// ---------------------------------------------------------------------------
+
+test('globalEventBus.emit notifies all subscribers', () => {
+  // Use a local bus to avoid cross-test pollution from the module singleton
+  const bus = createEventBus();
+  const receivedA = [];
+  const receivedB = [];
+
+  bus.subscribe((e) => receivedA.push(e));
+  bus.subscribe((e) => receivedB.push(e));
+
+  bus.emit({ type: 'integration-test', value: 'ping' });
+
+  assert.equal(receivedA.length, 1);
+  assert.equal(receivedB.length, 1);
+  assert.equal(receivedA[0].value, 'ping');
+  assert.equal(receivedB[0].value, 'ping');
+});
+
+test('globalEventBus is a shared singleton — same object across imports', async () => {
+  // Re-import to confirm it's the same singleton reference
+  const { globalEventBus: bus2 } = await import('../src/event-bus.js');
+  assert.strictEqual(globalEventBus, bus2, 'globalEventBus must be a module-level singleton');
+});
+
+// ---------------------------------------------------------------------------
+// emitResourceChange includes correct fields
+// ---------------------------------------------------------------------------
+
+test('emitResourceChange includes kind, name, operation, type, and timestamp fields', () => {
+  const bus = createEventBus();
+  const events = [];
+  bus.subscribe((e) => events.push(e));
+
+  bus.emitResourceChange('Repository', 'my-repo', 'apply');
+
+  assert.equal(events.length, 1);
+  const ev = events[0];
+  assert.equal(ev.type, 'resource-change');
+  assert.equal(ev.kind, 'Repository');
+  assert.equal(ev.name, 'my-repo');
+  assert.equal(ev.operation, 'apply');
+  assert.ok(typeof ev.timestamp === 'string', 'timestamp must be a string');
+  assert.ok(new Date(ev.timestamp).getTime() > 0, 'timestamp must be a valid ISO date');
+});
+
+test('emitResourceChange for delete operation includes operation: delete', () => {
+  const bus = createEventBus();
+  const events = [];
+  bus.subscribe((e) => events.push(e));
+
+  bus.emitResourceChange('AgentStack', 'review-bot', 'delete');
+
+  const ev = events[0];
+  assert.equal(ev.operation, 'delete');
+  assert.equal(ev.kind, 'AgentStack');
+  assert.equal(ev.name, 'review-bot');
+});
+
+test('emitResourceChange broadcasts to all currently subscribed listeners', () => {
+  const bus = createEventBus();
+  const counts = [0, 0, 0];
+  bus.subscribe(() => counts[0]++);
+  bus.subscribe(() => counts[1]++);
+  bus.subscribe(() => counts[2]++);
+
+  bus.emitResourceChange('Pipeline', 'ci-pipeline', 'apply');
+
+  assert.deepEqual(counts, [1, 1, 1]);
+});
+
+// ---------------------------------------------------------------------------
+// unsubscribe stops notifications
+// ---------------------------------------------------------------------------
+
+test('unsubscribe stops further notifications to the removed listener', () => {
+  const bus = createEventBus();
+  const events = [];
+  const listener = (e) => events.push(e);
+
+  bus.subscribe(listener);
+  bus.emit({ type: 'before-unsub' });
+
+  bus.unsubscribe(listener);
+  bus.emit({ type: 'after-unsub' });
+
+  assert.equal(events.length, 1);
+  assert.equal(events[0].type, 'before-unsub');
+});
+
+test('unsubscribing one listener does not affect other listeners', () => {
+  const bus = createEventBus();
+  const eventsA = [];
+  const eventsB = [];
+  const listenerA = (e) => eventsA.push(e);
+  const listenerB = (e) => eventsB.push(e);
+
+  bus.subscribe(listenerA);
+  bus.subscribe(listenerB);
+
+  bus.emit({ type: 'first' });
+  bus.unsubscribe(listenerA);
+  bus.emit({ type: 'second' });
+
+  assert.equal(eventsA.length, 1, 'listenerA should only have received the first event');
+  assert.equal(eventsB.length, 2, 'listenerB should have received both events');
+  assert.equal(eventsB[1].type, 'second');
+});
+
+test('unsubscribing a listener that was never subscribed is a no-op', () => {
+  const bus = createEventBus();
+  const listener = () => {};
+  // Should not throw
+  assert.doesNotThrow(() => bus.unsubscribe(listener));
+});
+
+// ---------------------------------------------------------------------------
+// Multiple subscribers receive same event
+// ---------------------------------------------------------------------------
+
+test('five subscribers all receive the same emitted event object', () => {
+  const bus = createEventBus();
+  const buckets = Array.from({ length: 5 }, () => []);
+  buckets.forEach((bucket) => bus.subscribe((e) => bucket.push(e)));
+
+  const event = { type: 'multi-fan-out', id: 'event-xyz' };
+  bus.emit(event);
+
+  for (const bucket of buckets) {
+    assert.equal(bucket.length, 1, 'each subscriber should receive exactly one event');
+    assert.strictEqual(bucket[0], event, 'each subscriber should receive the same event reference');
+  }
+});
+
+test('emit with zero subscribers does not throw and is a no-op', () => {
+  const bus = createEventBus();
+  assert.doesNotThrow(() => bus.emit({ type: 'nobody-home' }));
+});
+
+test('subscribers added after an emit do not receive previous events', () => {
+  const bus = createEventBus();
+  const events = [];
+
+  bus.emit({ type: 'before-subscribe' });
+  bus.subscribe((e) => events.push(e));
+
+  assert.equal(events.length, 0, 'late subscriber must not receive past events');
+});
+
+// ---------------------------------------------------------------------------
+// Sequential emit ordering
+// ---------------------------------------------------------------------------
+
+test('emit delivers events to subscribers in subscription order', () => {
+  const bus = createEventBus();
+  const order = [];
+
+  bus.subscribe(() => order.push('first'));
+  bus.subscribe(() => order.push('second'));
+  bus.subscribe(() => order.push('third'));
+
+  bus.emit({ type: 'ordering-test' });
+
+  assert.deepEqual(order, ['first', 'second', 'third']);
+});
+
+test('multiple emits are each delivered to all subscribers independently', () => {
+  const bus = createEventBus();
+  const events = [];
+  bus.subscribe((e) => events.push(e.id));
+
+  bus.emit({ id: 1 });
+  bus.emit({ id: 2 });
+  bus.emit({ id: 3 });
+
+  assert.deepEqual(events, [1, 2, 3]);
+});
+
+test('event bus assigns durable ids and can replay from a cursor', () => {
+  const bus = createEventBus({ transport: createMemoryEventTransport() });
+  const first = bus.emit({ type: 'resource-change', name: 'one' });
+  const second = bus.emit({ type: 'resource-change', name: 'two' });
+  const replayed = bus.replaySince(first.id);
+
+  assert.ok(first.id, 'first event has a stable cursor id');
+  assert.ok(second.id, 'second event has a stable cursor id');
+  assert.deepEqual(replayed.map((event) => event.name), ['two']);
+});
+
+test('two buses sharing a transport receive the same durable event', () => {
+  const transport = createMemoryEventTransport();
+  const publisher = createEventBus({ transport });
+  const subscriber = createEventBus({ transport });
+  const received = [];
+
+  subscriber.subscribe((event) => received.push(event));
+  publisher.emitResourceChange('Repository', 'shared-repo', 'apply');
+
+  assert.equal(received.length, 1);
+  assert.equal(received[0].kind, 'Repository');
+  assert.equal(received[0].name, 'shared-repo');
+});
+
+test('listener failures do not block durable emit or healthy subscribers', () => {
+  const bus = createEventBus({ transport: createMemoryEventTransport() });
+  const received = [];
+  bus.subscribe(() => {
+    throw new Error('slow subscriber failed');
+  });
+  bus.subscribe((event) => received.push(event));
+
+  const emitted = bus.emit({ type: 'backpressure-test' });
+
+  assert.equal(emitted.type, 'backpressure-test');
+  assert.equal(received.length, 1);
+  assert.equal(bus.status().transport, 'memory');
+});
+
+test('required broker outage is exposed in event bus status', () => {
+  const bus = createEventBus({
+    transport: {
+      name: 'nats-jetstream',
+      available: false,
+      required: true,
+      status: () => ({ transport: 'nats-jetstream', status: 'error', reason: 'broker-unavailable' }),
+      publish: () => {
+        throw new Error('broker-unavailable');
+      },
+      subscribe: () => () => {},
+      replaySince: () => [],
+    },
+  });
+
+  assert.deepEqual(bus.status(), { transport: 'nats-jetstream', status: 'error', reason: 'broker-unavailable' });
+  assert.throws(() => bus.emit({ type: 'must-not-silently-fallback' }), /broker-unavailable/);
+});
+
+test('event transport status redacts broker credentials', () => {
+  const bus = createEventBus({
+    transport: createNatsJetStreamEventTransport({
+      required: true,
+      brokerClient: {
+        publish: () => {},
+        subscribe: () => () => {},
+        replaySince: () => [],
+        status: () => ({ transport: 'nats-jetstream', status: 'error', reason: 'connect nats://user:pass@nats:4222?token=secret-token', durable: true }),
+      },
+    }),
+  });
+
+  const serialized = JSON.stringify(bus.status());
+  assert.equal(bus.status().status, 'error');
+  assert.doesNotMatch(serialized, /user:pass|secret-token/);
+  assert.match(serialized, /\[redacted\]/);
+});
+
+test('required broker mode rejects publish while broker is not ready', () => {
+  const bus = createEventBus({
+    transport: createNatsJetStreamEventTransport({
+      required: true,
+      brokerClient: {
+        publish: () => {},
+        subscribe: () => () => {},
+        replaySince: () => [],
+        status: () => ({ transport: 'nats-jetstream', status: 'connecting', durable: true }),
+      },
+    }),
+  });
+
+  assert.throws(() => bus.emit({ type: 'must-wait-for-broker' }), /broker-connecting/);
+});
+
+test('required broker mode waits for async publish acknowledgement before local delivery', async () => {
+  const bus = createEventBus({
+    transport: createNatsJetStreamEventTransport({
+      required: true,
+      brokerClient: {
+        publish: () => Promise.reject(new Error('jetstream-down')),
+        subscribe: () => () => {},
+        replaySince: () => [],
+        status: () => ({ transport: 'nats-jetstream', status: 'ok', durable: true }),
+      },
+    }),
+  });
+  const received = [];
+  bus.subscribe((event) => received.push(event));
+
+  await assert.rejects(bus.emit({ type: 'must-be-durable' }), /jetstream-down/);
+
+  assert.equal(received.length, 0, 'local subscribers must not see required broker events that were not durably published');
+  assert.equal(bus.status().status, 'error');
+  assert.equal(bus.status().reason, 'jetstream-down');
+});
+
+test('broker echo does not duplicate events for local subscribers', () => {
+  let brokerListener;
+  const transport = createNatsJetStreamEventTransport({
+    subject: 'kradle.echo.events',
+    brokerClient: {
+      publish: (_subject, event) => {
+        brokerListener?.(event);
+      },
+      replaySince: () => [],
+      subscribe: (_subject, listener) => {
+        brokerListener = listener;
+        return () => { brokerListener = null; };
+      },
+      status: () => ({ transport: 'nats-jetstream', status: 'ok', durable: true }),
+    },
+  });
+  const bus = createEventBus({ transport });
+  const received = [];
+  bus.subscribe((event) => received.push(event));
+
+  const emitted = bus.emit({ type: 'broker-echo' });
+
+  assert.equal(received.length, 1);
+  assert.equal(received[0].id, emitted.id);
+});
+
+test('NATS JetStream transport delegates durable publish and replay to broker client', async () => {
+  const published = [];
+  const transport = createNatsJetStreamEventTransport({
+    subject: 'kradle.test.events',
+    brokerClient: {
+      publish: (subject, event) => {
+        published.push({ subject, event });
+      },
+      replaySince: (subject, cursor, limit) => [{ id: `${cursor}-next`, subject, limit }],
+      subscribe: () => () => {},
+      status: () => ({ transport: 'nats-jetstream', status: 'ok', durable: true }),
+    },
+  });
+  const bus = createEventBus({ transport });
+  const emitted = bus.emit({ type: 'brokered' });
+  const replayed = await bus.replaySince(emitted.id, 5);
+
+  assert.equal(published[0].subject, 'kradle.test.events');
+  assert.equal(published[0].event.id, emitted.id);
+  assert.deepEqual(replayed, [{ id: `${emitted.id}-next`, subject: 'kradle.test.events', limit: 5 }]);
+  assert.equal(bus.status().durable, true);
+});