@alt-javascript/camel-lite-core 1.0.2

package/test/ProducerTemplate.test.js

@@ -0,0 +1,132 @@
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { CamelContext, ProducerTemplate, Exchange } from '../src/index.js';
+import { DirectComponent } from '@alt-javascript/camel-lite-component-direct';
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeContext() {
+  const ctx = new CamelContext();
+  ctx.addComponent('direct', new DirectComponent());
+  return ctx;
+}
+
+// ---------------------------------------------------------------------------
+// Unit tests (no running context)
+// ---------------------------------------------------------------------------
+
+describe('ProducerTemplate: constructor', () => {
+  it('throws when no context provided', () => {
+    assert.throws(() => new ProducerTemplate(null), /requires a CamelContext/);
+  });
+});
+
+describe('ProducerTemplate: sendBody (unit)', () => {
+  it('throws for unknown scheme', async () => {
+    const ctx = makeContext();
+    const pt = new ProducerTemplate(ctx);
+    await assert.rejects(
+      () => pt.sendBody('unknown:foo', 'body'),
+      /no component registered for scheme 'unknown'/
+    );
+  });
+
+  it('throws for URI with no scheme', async () => {
+    const ctx = makeContext();
+    const pt = new ProducerTemplate(ctx);
+    await assert.rejects(
+      () => pt.sendBody('nodots', 'body'),
+      /invalid URI/
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Integration tests (live context with direct: component)
+// ---------------------------------------------------------------------------
+
+describe('ProducerTemplate: sendBody integration', () => {
+  let ctx;
+
+  before(async () => {
+    ctx = makeContext();
+    const { RouteBuilder } = await import('../src/RouteBuilder.js');
+    const builder = new RouteBuilder();
+    builder.from('direct:upper').process(ex => {
+      ex.in.body = ex.in.body.toUpperCase();
+    });
+    ctx.addRoutes(builder);
+    await ctx.start();
+  });
+
+  after(async () => {
+    await ctx.stop();
+  });
+
+  it('sendBody dispatches through the route pipeline', async () => {
+    const pt = new ProducerTemplate(ctx);
+    const exchange = await pt.sendBody('direct:upper', 'hello');
+    assert.equal(exchange.in.body, 'HELLO');
+    assert.equal(exchange.exception, null);
+  });
+
+  it('sendBody passes headers through to the route', async () => {
+    const { RouteBuilder } = await import('../src/RouteBuilder.js');
+    const builder = new RouteBuilder();
+    builder.from('direct:echoHeader').process(ex => {
+      ex.in.body = ex.in.getHeader('x-test');
+    });
+    ctx.addRoutes(builder);
+    // no restart needed — direct: registers consumer on addRoutes start()
+    // but context is already started so we need to start consumer manually
+    // Actually the route is registered but not started — we need a second context start
+    // or use the consumer directly. Simpler: test header forwarding via existing route.
+    const pt = new ProducerTemplate(ctx);
+    const exchange = await pt.sendBody('direct:upper', 'world', { 'x-val': '42' });
+    assert.equal(exchange.in.getHeader('x-val'), '42');
+  });
+
+  it('sendBody returns exchange with no exception on success', async () => {
+    const pt = new ProducerTemplate(ctx);
+    const exchange = await pt.sendBody('direct:upper', 'test');
+    assert.equal(exchange.isFailed(), false);
+  });
+});
+
+describe('ProducerTemplate: requestBody integration', () => {
+  let ctx;
+
+  before(async () => {
+    ctx = makeContext();
+    const { RouteBuilder } = await import('../src/RouteBuilder.js');
+    const builder = new RouteBuilder();
+    // Route sets out.body explicitly (InOut response pattern)
+    builder.from('direct:echo-out').process(ex => {
+      ex.out.body = `echo:${ex.in.body}`;
+    });
+    // Route only mutates in.body (in-place pattern — requestBody falls back)
+    builder.from('direct:mutate-in').process(ex => {
+      ex.in.body = `mutated:${ex.in.body}`;
+    });
+    ctx.addRoutes(builder);
+    await ctx.start();
+  });
+
+  after(async () => {
+    await ctx.stop();
+  });
+
+  it('returns out.body when route sets it', async () => {
+    const pt = new ProducerTemplate(ctx);
+    const result = await pt.requestBody('direct:echo-out', 'ping');
+    assert.equal(result, 'echo:ping');
+  });
+
+  it('falls back to in.body when out.body is not set', async () => {
+    const pt = new ProducerTemplate(ctx);
+    const result = await pt.requestBody('direct:mutate-in', 'data');
+    assert.equal(result, 'mutated:data');
+  });
+});

package/test/context.test.js

@@ -0,0 +1,97 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { CamelContext } from '../src/CamelContext.js';
+
+describe('CamelContext', () => {
+  it('constructs without error', () => {
+    const ctx = new CamelContext();
+    assert.ok(ctx instanceof CamelContext);
+  });
+
+  it('started is false initially', () => {
+    const ctx = new CamelContext();
+    assert.equal(ctx.started, false);
+  });
+
+  it('start() is async and sets started to true', async () => {
+    const ctx = new CamelContext();
+    await ctx.start();
+    assert.equal(ctx.started, true);
+  });
+
+  it('stop() sets started to false', async () => {
+    const ctx = new CamelContext();
+    await ctx.start();
+    await ctx.stop();
+    assert.equal(ctx.started, false);
+  });
+
+  it('addComponent returns this (fluent)', () => {
+    const ctx = new CamelContext();
+    const stub = {};
+    const result = ctx.addComponent('test', stub);
+    assert.equal(result, ctx);
+  });
+
+  it('getComponent returns the registered component', () => {
+    const ctx = new CamelContext();
+    const stub = { name: 'stubComponent' };
+    ctx.addComponent('direct', stub);
+    assert.equal(ctx.getComponent('direct'), stub);
+  });
+
+  it('addComponent is chainable', () => {
+    const ctx = new CamelContext();
+    const a = { id: 'a' };
+    const b = { id: 'b' };
+    ctx.addComponent('a', a).addComponent('b', b);
+    assert.equal(ctx.getComponent('a'), a);
+    assert.equal(ctx.getComponent('b'), b);
+  });
+});
+
+describe('CamelContext bean registry', () => {
+  it('registerBean/getBean round-trips a bean by name', () => {
+    const ctx = new CamelContext();
+    const db = { type: 'sqlite' };
+    ctx.registerBean('myDb', db);
+    assert.equal(ctx.getBean('myDb'), db);
+  });
+
+  it('getBean returns undefined for unknown name', () => {
+    const ctx = new CamelContext();
+    assert.equal(ctx.getBean('ghost'), undefined);
+  });
+
+  it('getBeans returns all registered beans as [name, bean] pairs', () => {
+    const ctx = new CamelContext();
+    const db1 = { id: 1 };
+    const db2 = { id: 2 };
+    ctx.registerBean('ds1', db1);
+    ctx.registerBean('ds2', db2);
+    const entries = ctx.getBeans();
+    assert.equal(entries.length, 2);
+    assert.deepEqual(entries.find(([n]) => n === 'ds1')?.[1], db1);
+    assert.deepEqual(entries.find(([n]) => n === 'ds2')?.[1], db2);
+  });
+
+  it('getBeans returns empty array when no beans registered', () => {
+    const ctx = new CamelContext();
+    assert.deepEqual(ctx.getBeans(), []);
+  });
+
+  it('registerBean is fluent (returns context)', () => {
+    const ctx = new CamelContext();
+    const result = ctx.registerBean('x', {});
+    assert.equal(result, ctx);
+  });
+
+  it('registerBean overwrites existing bean with same name', () => {
+    const ctx = new CamelContext();
+    const orig = { v: 1 };
+    const updated = { v: 2 };
+    ctx.registerBean('key', orig);
+    ctx.registerBean('key', updated);
+    assert.equal(ctx.getBean('key'), updated);
+  });
+});

package/test/dsl.test.js

@@ -0,0 +1,375 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  Exchange, CamelContext, RouteDefinition,
+  simple, js, constant,
+} from '../src/index.js';
+import { Pipeline } from '../src/Pipeline.js';
+
+// ---------------------------------------------------------------------------
+// Helper: compile a RouteDefinition to a Pipeline and run it against an exchange
+// ---------------------------------------------------------------------------
+
+function makeExchange(body) {
+  const ex = new Exchange();
+  ex.in.body = body;
+  return ex;
+}
+
+async function run(routeDef, exchange, context = null) {
+  const pipeline = routeDef.compile(context);
+  await pipeline.run(exchange);
+  return exchange;
+}
+
+// ---------------------------------------------------------------------------
+// constant() expression
+// ---------------------------------------------------------------------------
+
+describe('constant() expression', () => {
+  it('always returns the given value regardless of exchange', async () => {
+    const fn = constant('hello');
+    assert.equal(typeof fn._fn, 'function');
+    assert.equal(fn._fn(), 'hello');
+    assert.equal(fn._fn({ whatever: true }), 'hello');
+  });
+
+  it('works with normaliseExpression', () => {
+    // constant returns a _camelExpr object compatible with normaliseExpression
+    const expr = constant(42);
+    assert.ok(expr._camelExpr);
+    assert.equal(expr._fn(), 42);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// setBody
+// ---------------------------------------------------------------------------
+
+describe('setBody()', () => {
+  it('replaces body with constant expression', async () => {
+    const route = new RouteDefinition('direct:test');
+    route.setBody(constant('hello'));
+    const ex = makeExchange('original');
+    await run(route, ex);
+    assert.equal(ex.in.body, 'hello');
+  });
+
+  it('replaces body with simple expression referencing a header', async () => {
+    const route = new RouteDefinition('direct:test');
+    route.setBody(simple('${header.X-Type}'));
+    const ex = makeExchange('original');
+    ex.in.setHeader('X-Type', 'order');
+    await run(route, ex);
+    assert.equal(ex.in.body, 'order');
+  });
+
+  it('replaces body with js expression', async () => {
+    const route = new RouteDefinition('direct:test');
+    route.setBody(js('exchange.in.body.toUpperCase()'));
+    const ex = makeExchange('hello');
+    await run(route, ex);
+    assert.equal(ex.in.body, 'HELLO');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// setHeader
+// ---------------------------------------------------------------------------
+
+describe('setHeader()', () => {
+  it('sets a header with constant value', async () => {
+    const route = new RouteDefinition('direct:test');
+    route.setHeader('X-Source', constant('camel-lite'));
+    const ex = makeExchange('body');
+    await run(route, ex);
+    assert.equal(ex.in.getHeader('X-Source'), 'camel-lite');
+  });
+
+  it('sets a header from body via simple expression', async () => {
+    const route = new RouteDefinition('direct:test');
+    route.setHeader('X-Body', simple('${body}'));
+    const ex = makeExchange('my-value');
+    await run(route, ex);
+    assert.equal(ex.in.getHeader('X-Body'), 'my-value');
+  });
+
+  it('does not modify exchange body', async () => {
+    const route = new RouteDefinition('direct:test');
+    route.setHeader('X-Foo', constant('bar'));
+    const ex = makeExchange('unchanged');
+    await run(route, ex);
+    assert.equal(ex.in.body, 'unchanged');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// setProperty
+// ---------------------------------------------------------------------------
+
+describe('setProperty()', () => {
+  it('sets an exchange property with js expression', async () => {
+    const route = new RouteDefinition('direct:test');
+    route.setBody(constant({ name: 'Alice' }));
+    route.setProperty('saved', js('exchange.in.body'));
+    const ex = makeExchange(null);
+    await run(route, ex);
+    assert.deepEqual(ex.getProperty('saved'), { name: 'Alice' });
+  });
+
+  it('sets property with constant', async () => {
+    const route = new RouteDefinition('direct:test');
+    route.setProperty('version', constant(2));
+    const ex = makeExchange(null);
+    await run(route, ex);
+    assert.equal(ex.getProperty('version'), 2);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// removeHeader
+// ---------------------------------------------------------------------------
+
+describe('removeHeader()', () => {
+  it('removes a named header from the exchange', async () => {
+    const route = new RouteDefinition('direct:test');
+    route.removeHeader('X-Temp');
+    const ex = makeExchange('body');
+    ex.in.setHeader('X-Temp', 'to-be-removed');
+    await run(route, ex);
+    assert.equal(ex.in.getHeader('X-Temp'), undefined);
+  });
+
+  it('does not throw when header is absent', async () => {
+    const route = new RouteDefinition('direct:test');
+    route.removeHeader('X-Missing');
+    const ex = makeExchange('body');
+    await assert.doesNotReject(() => run(route, ex));
+  });
+});
+
+// ---------------------------------------------------------------------------
+// log
+// ---------------------------------------------------------------------------
+
+describe('log()', () => {
+  it('does not throw and does not modify exchange body', async () => {
+    const route = new RouteDefinition('direct:test');
+    route.log('hello from route');
+    const ex = makeExchange('original-body');
+    await assert.doesNotReject(() => run(route, ex));
+    assert.equal(ex.in.body, 'original-body');
+  });
+
+  it('accepts a simple() expression as message', async () => {
+    // simple() expressions must be pure expressions, not text with embedded values.
+    // For log, use a js() expression to build a formatted message string.
+    const route = new RouteDefinition('direct:test');
+    route.log(js('`body is ${exchange.in.body}`'));
+    const ex = makeExchange('test-value');
+    await assert.doesNotReject(() => run(route, ex));
+  });
+});
+
+// ---------------------------------------------------------------------------
+// marshal / unmarshal
+// ---------------------------------------------------------------------------
+
+describe('marshal()', () => {
+  it('serialises object body to JSON string', async () => {
+    const route = new RouteDefinition('direct:test');
+    route.marshal('json');
+    const ex = makeExchange({ name: 'Widget', price: 9.99 });
+    await run(route, ex);
+    assert.equal(typeof ex.in.body, 'string');
+    const parsed = JSON.parse(ex.in.body);
+    assert.equal(parsed.name, 'Widget');
+  });
+
+  it('defaults to json format', async () => {
+    const route = new RouteDefinition('direct:test');
+    route.marshal(); // no arg
+    const ex = makeExchange({ x: 1 });
+    await run(route, ex);
+    assert.equal(ex.in.body, '{"x":1}');
+  });
+});
+
+describe('unmarshal()', () => {
+  it('deserialises JSON string to object', async () => {
+    const route = new RouteDefinition('direct:test');
+    route.unmarshal('json');
+    const ex = makeExchange('{"name":"Gadget","price":24.99}');
+    await run(route, ex);
+    assert.equal(ex.in.body.name, 'Gadget');
+    assert.equal(ex.in.body.price, 24.99);
+  });
+});
+
+describe('marshal → unmarshal round-trip', () => {
+  it('round-trips an object through JSON serialisation', async () => {
+    const original = { id: 1, tags: ['a', 'b'], nested: { x: true } };
+    const route = new RouteDefinition('direct:test');
+    route.marshal().unmarshal();
+    const ex = makeExchange(original);
+    await run(route, ex);
+    assert.deepEqual(ex.in.body, original);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// convertBodyTo
+// ---------------------------------------------------------------------------
+
+describe('convertBodyTo()', () => {
+  it('converts number to String', async () => {
+    const route = new RouteDefinition('direct:test');
+    route.convertBodyTo('String');
+    const ex = makeExchange(42);
+    await run(route, ex);
+    assert.equal(ex.in.body, '42');
+    assert.equal(typeof ex.in.body, 'string');
+  });
+
+  it('converts string to Number', async () => {
+    const route = new RouteDefinition('direct:test');
+    route.convertBodyTo('Number');
+    const ex = makeExchange('3.14');
+    await run(route, ex);
+    assert.equal(ex.in.body, 3.14);
+    assert.equal(typeof ex.in.body, 'number');
+  });
+
+  it('converts string "true" to Boolean true', async () => {
+    const route = new RouteDefinition('direct:test');
+    route.convertBodyTo('Boolean');
+    const ex = makeExchange('true');
+    await run(route, ex);
+    assert.equal(ex.in.body, true);
+  });
+
+  it('converts string "false" to Boolean false', async () => {
+    const route = new RouteDefinition('direct:test');
+    route.convertBodyTo('Boolean');
+    const ex = makeExchange('false');
+    await run(route, ex);
+    assert.equal(ex.in.body, false);
+  });
+
+  it('throws on unsupported type', async () => {
+    const route = new RouteDefinition('direct:test');
+    route.convertBodyTo('Date');
+    const ex = makeExchange('2024-01-01');
+    await run(route, ex);
+    // Pipeline captures errors on exchange.exception
+    assert.ok(ex.exception != null, 'exchange should have an exception');
+    assert.match(ex.exception.message, /unsupported type 'Date'/i);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// stop
+// ---------------------------------------------------------------------------
+
+describe('stop()', () => {
+  it('stops exchange processing cleanly — body not modified by subsequent steps', async () => {
+    const route = new RouteDefinition('direct:test');
+    route
+      .setBody(constant('before-stop'))
+      .stop()
+      .setBody(constant('after-stop')); // should not execute
+
+    const ex = makeExchange('initial');
+    // Pipeline swallows CamelFilterStopException — no exception to caller
+    await assert.doesNotReject(() => run(route, ex));
+    assert.equal(ex.in.body, 'before-stop');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// bean
+// ---------------------------------------------------------------------------
+
+describe('bean() with function', () => {
+  it('executes a function processor', async () => {
+    const route = new RouteDefinition('direct:test');
+    route.bean(async (exchange) => { exchange.in.body = 'from-bean-fn'; });
+    const ex = makeExchange('original');
+    await run(route, ex);
+    assert.equal(ex.in.body, 'from-bean-fn');
+  });
+});
+
+describe('bean() with object', () => {
+  it('executes an object with process() method', async () => {
+    const processor = {
+      async process(exchange) { exchange.in.body = 'from-bean-obj'; },
+    };
+    const route = new RouteDefinition('direct:test');
+    route.bean(processor);
+    const ex = makeExchange('original');
+    await run(route, ex);
+    assert.equal(ex.in.body, 'from-bean-obj');
+  });
+});
+
+describe('bean() with string name (context lookup)', () => {
+  it('looks up bean from context at runtime and executes it', async () => {
+    const ctx = new CamelContext();
+    ctx.registerBean('myProc', async (exchange) => { exchange.in.body = 'from-ctx-bean'; });
+
+    const route = new RouteDefinition('direct:test');
+    route.bean('myProc');
+    const ex = makeExchange('original');
+    const pipeline = route.compile(ctx);
+    await pipeline.run(ex);
+    assert.equal(ex.in.body, 'from-ctx-bean');
+  });
+
+  it('throws descriptively when bean not found in context', async () => {
+    const ctx = new CamelContext();
+    const route = new RouteDefinition('direct:test');
+    route.bean('ghost');
+    const ex = makeExchange('x');
+    const pipeline = route.compile(ctx);
+    await pipeline.run(ex);
+    // Pipeline captures error on exchange.exception
+    assert.ok(ex.exception != null, 'exchange should have an exception');
+    assert.match(ex.exception.message, /bean\('ghost'\).*no bean registered/i);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Chained pipeline integration
+// ---------------------------------------------------------------------------
+
+describe('chained new DSL steps integration', () => {
+  it('setHeader → setBody(simple) → setProperty → marshal → unmarshal round-trip', async () => {
+    const ctx = new CamelContext();
+    const route = new RouteDefinition('direct:test');
+    route
+      .setHeader('X-Type', constant('invoice'))
+      .setBody(simple('${header.X-Type}'))
+      .setProperty('type', js('exchange.in.body'))
+      .setBody(constant({ amount: 100, currency: 'USD' }))
+      .marshal()
+      .unmarshal();
+
+    const ex = makeExchange(null);
+    const pipeline = route.compile(ctx);
+    await pipeline.run(ex);
+
+    assert.equal(ex.in.getHeader('X-Type'), 'invoice');
+    assert.equal(ex.getProperty('type'), 'invoice');
+    assert.equal(ex.in.body.amount, 100);
+    assert.equal(ex.in.body.currency, 'USD');
+  });
+
+  it('convertBodyTo after marshal converts JSON string to String type (no-op)', async () => {
+    const route = new RouteDefinition('direct:test');
+    route.marshal().convertBodyTo('String');
+    const ex = makeExchange({ x: 1 });
+    await run(route, ex);
+    assert.equal(typeof ex.in.body, 'string');
+  });
+});