@relaybus/testing 0.3.1 → 0.4.0

package/dist/index.d.cts

@@ -83,4 +83,145 @@ declare class InMemoryTransport implements Transport {
     close(): Promise<void>;
 }
 
-export { type EventStoreContractOptions, FakeClock, InMemoryTransport, type PublishedMessage, at, createDelivery, createEnvelope, eventStoreContract };
+/** How message bodies are compared: byte for byte, or as JSON regardless of key order and spacing. */
+type BodyComparison = 'bytes' | 'json';
+/** Bytes as text or bytes, as captured or encoded. */
+type WireBytes = string | Uint8Array;
+
+/** A record as captured from a topic: what an existing producer wrote. */
+interface KafkaCapturedRecord {
+    readonly topic: string;
+    /** Default 0. */
+    readonly partition?: number;
+    /** Default `'0'`. */
+    readonly offset?: string;
+    readonly key: WireBytes | null;
+    readonly value: WireBytes | null;
+    /** Default none. */
+    readonly headers?: Readonly<Record<string, WireBytes>>;
+    /** Epoch milliseconds in a string; compared only when the codec sets a timestamp. */
+    readonly timestamp?: string;
+}
+/** What a codec's `encode` returns: a `KafkaCodec` record. */
+interface KafkaWrittenRecord {
+    readonly key: WireBytes | null;
+    readonly value: WireBytes | null;
+    readonly headers: Readonly<Record<string, WireBytes | readonly WireBytes[]>>;
+    readonly timestamp?: string;
+}
+/** A record as a consumer hands it over: bytes for the key, the value and every header. */
+interface KafkaDeliveredRecord {
+    readonly topic: string;
+    readonly partition: number;
+    readonly offset: string;
+    readonly key: Buffer | null;
+    readonly value: Buffer | null;
+    readonly headers: Readonly<Record<string, Buffer>>;
+    readonly timestamp?: string;
+}
+/** One message of the format: the event and the record that carries it. */
+interface KafkaCodecCase {
+    readonly name: string;
+    readonly envelope: EventEnvelope;
+    readonly record: KafkaCapturedRecord;
+    /**
+     * The event decoding the record gives, when the wire does not carry all of `envelope` (for
+     * example a record written without a key). Default `envelope`.
+     */
+    readonly decoded?: EventEnvelope;
+    /**
+     * Checks one direction only: `'decode'` for a message only other producers write (for
+     * example one without an id, which relaybus would add), `'encode'` for one only other
+     * consumers read. Default both.
+     */
+    readonly only?: 'encode' | 'decode';
+}
+interface KafkaCodecContractOptions {
+    /** Writes an event: a codec's `encode`, or a transport's publish captured by an injected producer. */
+    readonly encode: (envelope: EventEnvelope) => KafkaWrittenRecord | Promise<KafkaWrittenRecord>;
+    /** Reads a record the way the transport does: `(record) => decodeKafkaRecord(codec, record)`. */
+    readonly decode: (record: KafkaDeliveredRecord) => EventEnvelope | Promise<EventEnvelope>;
+    readonly cases: readonly KafkaCodecCase[];
+    /** How values are compared. Default `'bytes'`. */
+    readonly compare?: BodyComparison;
+    /** Headers left out of the comparison, such as ones relaybus adds and other consumers ignore. */
+    readonly ignoreHeaders?: readonly string[];
+}
+/**
+ * What differs between `testCase` and what the codec writes and reads, one line each: the key,
+ * the value, the headers (a repeated header by its last value) and the timestamp of
+ * `encode(envelope)`, and `decode(record)` against the expected event. Empty when they agree.
+ */
+declare function kafkaCodecMismatches(options: KafkaCodecContractOptions, testCase: KafkaCodecCase): Promise<string[]>;
+/**
+ * Registers one test per case asserting {@link kafkaCodecMismatches} finds nothing: a format of
+ * existing producers and consumers is adopted only once relaybus writes and reads it exactly.
+ */
+declare function kafkaCodecContract(name: string, options: KafkaCodecContractOptions): void;
+
+/** A message as captured from a queue: what an existing publisher wrote. */
+interface RabbitMqCapturedMessage {
+    readonly routingKey: string;
+    /**
+     * The message properties as publish options name them (`persistent`, `messageId`,
+     * `contentType`, `timestamp`, ...), without `headers`. Default none.
+     */
+    readonly properties?: Readonly<Record<string, unknown>>;
+    /** Default none. */
+    readonly headers?: Readonly<Record<string, unknown>>;
+    readonly body: WireBytes;
+}
+/** What a codec's `encode` returns: a `RabbitMqCodec` message. */
+interface RabbitMqWrittenMessage {
+    readonly content: Uint8Array;
+    /** The publish options: properties, and the headers under `headers`. */
+    readonly options: object;
+}
+/** A message as a consumer receives it. */
+interface RabbitMqDeliveredMessage {
+    readonly content: Buffer;
+    readonly fields: {
+        readonly routingKey: string;
+    };
+    readonly properties: Readonly<Record<string, unknown>> & {
+        readonly headers: Readonly<Record<string, unknown>>;
+    };
+}
+/** One message of the format: the event and the message that carries it. */
+interface RabbitMqCodecCase {
+    readonly name: string;
+    readonly envelope: EventEnvelope;
+    readonly message: RabbitMqCapturedMessage;
+    /** The event decoding the message gives, when the wire does not carry all of `envelope`. */
+    readonly decoded?: EventEnvelope;
+    /**
+     * Checks one direction only: `'decode'` for a message only other producers write (for
+     * example one without an id, which relaybus would add), `'encode'` for one only other
+     * consumers read. Default both.
+     */
+    readonly only?: 'encode' | 'decode';
+}
+interface RabbitMqCodecContractOptions {
+    /** Writes an event: a codec's `encode`. The routing key is the route's destination, not the codec's. */
+    readonly encode: (envelope: EventEnvelope) => RabbitMqWrittenMessage | Promise<RabbitMqWrittenMessage>;
+    /** Reads a message the way the transport does: `(message) => decodeRabbitMqMessage(codec, message)`. */
+    readonly decode: (message: RabbitMqDeliveredMessage) => EventEnvelope | Promise<EventEnvelope>;
+    readonly cases: readonly RabbitMqCodecCase[];
+    /** How bodies are compared. Default `'bytes'`. */
+    readonly compare?: BodyComparison;
+    /** Properties left out of the comparison, such as a `timestamp` that differs per send. */
+    readonly ignoreProperties?: readonly string[];
+    /** Headers left out of the comparison. */
+    readonly ignoreHeaders?: readonly string[];
+}
+/**
+ * What differs between `testCase` and what the codec writes and reads, one line each: the
+ * properties, headers and body of `encode(envelope)`, and `decode(message)` against the expected
+ * event. Empty when they agree.
+ */
+declare function rabbitMqCodecMismatches(options: RabbitMqCodecContractOptions, testCase: RabbitMqCodecCase): Promise<string[]>;
+/** Registers one test per case asserting {@link rabbitMqCodecMismatches} finds nothing. */
+declare function rabbitMqCodecContract(name: string, options: RabbitMqCodecContractOptions): void;
+
+export { FakeClock, InMemoryTransport, at, createDelivery, createEnvelope, eventStoreContract, kafkaCodecContract, kafkaCodecMismatches, rabbitMqCodecContract, rabbitMqCodecMismatches };
+export type { BodyComparison, EventStoreContractOptions, KafkaCapturedRecord, KafkaCodecCase, KafkaCodecContractOptions, KafkaDeliveredRecord, KafkaWrittenRecord, PublishedMessage, RabbitMqCapturedMessage, RabbitMqCodecCase, RabbitMqCodecContractOptions, RabbitMqDeliveredMessage, RabbitMqWrittenMessage, WireBytes };

package/dist/index.d.ts

@@ -83,4 +83,145 @@ declare class InMemoryTransport implements Transport {
     close(): Promise<void>;
 }
 
-export { type EventStoreContractOptions, FakeClock, InMemoryTransport, type PublishedMessage, at, createDelivery, createEnvelope, eventStoreContract };
+/** How message bodies are compared: byte for byte, or as JSON regardless of key order and spacing. */
+type BodyComparison = 'bytes' | 'json';
+/** Bytes as text or bytes, as captured or encoded. */
+type WireBytes = string | Uint8Array;
+
+/** A record as captured from a topic: what an existing producer wrote. */
+interface KafkaCapturedRecord {
+    readonly topic: string;
+    /** Default 0. */
+    readonly partition?: number;
+    /** Default `'0'`. */
+    readonly offset?: string;
+    readonly key: WireBytes | null;
+    readonly value: WireBytes | null;
+    /** Default none. */
+    readonly headers?: Readonly<Record<string, WireBytes>>;
+    /** Epoch milliseconds in a string; compared only when the codec sets a timestamp. */
+    readonly timestamp?: string;
+}
+/** What a codec's `encode` returns: a `KafkaCodec` record. */
+interface KafkaWrittenRecord {
+    readonly key: WireBytes | null;
+    readonly value: WireBytes | null;
+    readonly headers: Readonly<Record<string, WireBytes | readonly WireBytes[]>>;
+    readonly timestamp?: string;
+}
+/** A record as a consumer hands it over: bytes for the key, the value and every header. */
+interface KafkaDeliveredRecord {
+    readonly topic: string;
+    readonly partition: number;
+    readonly offset: string;
+    readonly key: Buffer | null;
+    readonly value: Buffer | null;
+    readonly headers: Readonly<Record<string, Buffer>>;
+    readonly timestamp?: string;
+}
+/** One message of the format: the event and the record that carries it. */
+interface KafkaCodecCase {
+    readonly name: string;
+    readonly envelope: EventEnvelope;
+    readonly record: KafkaCapturedRecord;
+    /**
+     * The event decoding the record gives, when the wire does not carry all of `envelope` (for
+     * example a record written without a key). Default `envelope`.
+     */
+    readonly decoded?: EventEnvelope;
+    /**
+     * Checks one direction only: `'decode'` for a message only other producers write (for
+     * example one without an id, which relaybus would add), `'encode'` for one only other
+     * consumers read. Default both.
+     */
+    readonly only?: 'encode' | 'decode';
+}
+interface KafkaCodecContractOptions {
+    /** Writes an event: a codec's `encode`, or a transport's publish captured by an injected producer. */
+    readonly encode: (envelope: EventEnvelope) => KafkaWrittenRecord | Promise<KafkaWrittenRecord>;
+    /** Reads a record the way the transport does: `(record) => decodeKafkaRecord(codec, record)`. */
+    readonly decode: (record: KafkaDeliveredRecord) => EventEnvelope | Promise<EventEnvelope>;
+    readonly cases: readonly KafkaCodecCase[];
+    /** How values are compared. Default `'bytes'`. */
+    readonly compare?: BodyComparison;
+    /** Headers left out of the comparison, such as ones relaybus adds and other consumers ignore. */
+    readonly ignoreHeaders?: readonly string[];
+}
+/**
+ * What differs between `testCase` and what the codec writes and reads, one line each: the key,
+ * the value, the headers (a repeated header by its last value) and the timestamp of
+ * `encode(envelope)`, and `decode(record)` against the expected event. Empty when they agree.
+ */
+declare function kafkaCodecMismatches(options: KafkaCodecContractOptions, testCase: KafkaCodecCase): Promise<string[]>;
+/**
+ * Registers one test per case asserting {@link kafkaCodecMismatches} finds nothing: a format of
+ * existing producers and consumers is adopted only once relaybus writes and reads it exactly.
+ */
+declare function kafkaCodecContract(name: string, options: KafkaCodecContractOptions): void;
+
+/** A message as captured from a queue: what an existing publisher wrote. */
+interface RabbitMqCapturedMessage {
+    readonly routingKey: string;
+    /**
+     * The message properties as publish options name them (`persistent`, `messageId`,
+     * `contentType`, `timestamp`, ...), without `headers`. Default none.
+     */
+    readonly properties?: Readonly<Record<string, unknown>>;
+    /** Default none. */
+    readonly headers?: Readonly<Record<string, unknown>>;
+    readonly body: WireBytes;
+}
+/** What a codec's `encode` returns: a `RabbitMqCodec` message. */
+interface RabbitMqWrittenMessage {
+    readonly content: Uint8Array;
+    /** The publish options: properties, and the headers under `headers`. */
+    readonly options: object;
+}
+/** A message as a consumer receives it. */
+interface RabbitMqDeliveredMessage {
+    readonly content: Buffer;
+    readonly fields: {
+        readonly routingKey: string;
+    };
+    readonly properties: Readonly<Record<string, unknown>> & {
+        readonly headers: Readonly<Record<string, unknown>>;
+    };
+}
+/** One message of the format: the event and the message that carries it. */
+interface RabbitMqCodecCase {
+    readonly name: string;
+    readonly envelope: EventEnvelope;
+    readonly message: RabbitMqCapturedMessage;
+    /** The event decoding the message gives, when the wire does not carry all of `envelope`. */
+    readonly decoded?: EventEnvelope;
+    /**
+     * Checks one direction only: `'decode'` for a message only other producers write (for
+     * example one without an id, which relaybus would add), `'encode'` for one only other
+     * consumers read. Default both.
+     */
+    readonly only?: 'encode' | 'decode';
+}
+interface RabbitMqCodecContractOptions {
+    /** Writes an event: a codec's `encode`. The routing key is the route's destination, not the codec's. */
+    readonly encode: (envelope: EventEnvelope) => RabbitMqWrittenMessage | Promise<RabbitMqWrittenMessage>;
+    /** Reads a message the way the transport does: `(message) => decodeRabbitMqMessage(codec, message)`. */
+    readonly decode: (message: RabbitMqDeliveredMessage) => EventEnvelope | Promise<EventEnvelope>;
+    readonly cases: readonly RabbitMqCodecCase[];
+    /** How bodies are compared. Default `'bytes'`. */
+    readonly compare?: BodyComparison;
+    /** Properties left out of the comparison, such as a `timestamp` that differs per send. */
+    readonly ignoreProperties?: readonly string[];
+    /** Headers left out of the comparison. */
+    readonly ignoreHeaders?: readonly string[];
+}
+/**
+ * What differs between `testCase` and what the codec writes and reads, one line each: the
+ * properties, headers and body of `encode(envelope)`, and `decode(message)` against the expected
+ * event. Empty when they agree.
+ */
+declare function rabbitMqCodecMismatches(options: RabbitMqCodecContractOptions, testCase: RabbitMqCodecCase): Promise<string[]>;
+/** Registers one test per case asserting {@link rabbitMqCodecMismatches} finds nothing. */
+declare function rabbitMqCodecContract(name: string, options: RabbitMqCodecContractOptions): void;
+
+export { FakeClock, InMemoryTransport, at, createDelivery, createEnvelope, eventStoreContract, kafkaCodecContract, kafkaCodecMismatches, rabbitMqCodecContract, rabbitMqCodecMismatches };
+export type { BodyComparison, EventStoreContractOptions, KafkaCapturedRecord, KafkaCodecCase, KafkaCodecContractOptions, KafkaDeliveredRecord, KafkaWrittenRecord, PublishedMessage, RabbitMqCapturedMessage, RabbitMqCodecCase, RabbitMqCodecContractOptions, RabbitMqDeliveredMessage, RabbitMqWrittenMessage, WireBytes };

package/dist/index.js

@@ -1,5 +1,5 @@
 import { describe, beforeEach, afterEach, it, expect } from 'vitest';
-import { createUuidV7 } from '@relaybus/core';
+import { createUuidV7, toErrorInfo } from '@relaybus/core';
 
 // src/event-store-contract.ts
 function createDeferred() {
@@ -1404,18 +1404,186 @@ var InMemoryTransport = class {
   }
 };
 async function deliverWithRedeliveries(handler, delivery) {
-  for (let attempt = 0; ; attempt += 1) {
+  for (let attempt2 = 0; ; attempt2 += 1) {
     try {
       await handler(delivery.envelope, { destination: delivery.destination });
-      return attempt + 1;
+      return attempt2 + 1;
     } catch (error) {
-      if (attempt >= delivery.maxRedeliveries) {
+      if (attempt2 >= delivery.maxRedeliveries) {
         throw error;
       }
     }
   }
 }
+function toBuffer(bytes) {
+  return typeof bytes === "string" ? Buffer.from(bytes, "utf8") : Buffer.from(bytes);
+}
+function canonicalJson(value) {
+  return JSON.stringify(sortKeys(JSON.parse(JSON.stringify(value) ?? "null")));
+}
+function sortKeys(value) {
+  if (Array.isArray(value)) {
+    return value.map(sortKeys);
+  }
+  if (typeof value !== "object" || value === null) {
+    return value;
+  }
+  return Object.fromEntries(
+    Object.keys(value).sort().map((name) => [name, sortKeys(value[name])])
+  );
+}
+function compareBodies(label, {
+  expected,
+  encoded,
+  comparison
+}) {
+  const text = (bytes) => bytes === null ? "null" : toBuffer(bytes).toString("utf8");
+  const same = expected === null || encoded === null ? expected === encoded : comparison === "json" ? canonicalJson(JSON.parse(text(expected))) === canonicalJson(JSON.parse(text(encoded))) : toBuffer(expected).equals(toBuffer(encoded));
+  return same ? [] : [`${label}: expected ${text(expected)}, encoded ${text(encoded)}`];
+}
+function compareObjects(label, {
+  expected,
+  encoded,
+  ignored
+}) {
+  const kept = (object) => canonicalJson(
+    Object.fromEntries(Object.entries(object).filter(([name]) => !ignored.includes(name)))
+  );
+  const [left, right] = [kept(expected), kept(encoded)];
+  return left === right ? [] : [`${label}: expected ${left}, encoded ${right}`];
+}
+function compareDecoded(expected, decoded) {
+  const [left, right] = [canonicalJson(expected), canonicalJson(decoded)];
+  return left === right ? [] : [`decoded: expected ${left}, decoded ${right}`];
+}
+async function attempt(label, step) {
+  try {
+    return { result: await step(), mismatches: [] };
+  } catch (error) {
+    return { mismatches: [`${label} threw: ${toErrorInfo(error).message}`] };
+  }
+}
+
+// src/codec-contract/kafka.ts
+async function kafkaCodecMismatches(options, testCase) {
+  const { record } = testCase;
+  const encoding = testCase.only === "decode" ? { mismatches: [] } : await attempt("encode", () => options.encode(testCase.envelope));
+  const encoded = encoding.result;
+  const decoding = testCase.only === "encode" ? { mismatches: [] } : await attempt("decode", () => options.decode(delivered(record)));
+  return [
+    ...encoding.mismatches,
+    ...encoded === void 0 ? [] : compareRecords(options, { record, encoded }),
+    ...decoding.mismatches,
+    ...decoding.result === void 0 ? [] : compareDecoded(testCase.decoded ?? testCase.envelope, decoding.result)
+  ];
+}
+function kafkaCodecContract(name, options) {
+  describe(`${name} writes and reads the captured Kafka records`, () => {
+    it.each(options.cases.map((testCase) => [testCase.name, testCase]))(
+      "%s",
+      async (_name, testCase) => {
+        expect(await kafkaCodecMismatches(options, testCase)).toEqual([]);
+      }
+    );
+  });
+}
+function compareRecords(options, {
+  record,
+  encoded
+}) {
+  const text = (bytes) => bytes === null ? null : toBuffer(bytes).toString("utf8");
+  const timestamp = encoded.timestamp;
+  return [
+    ...text(record.key) === text(encoded.key) ? [] : [`key: expected ${text(record.key)}, encoded ${text(encoded.key)}`],
+    ...compareBodies("value", {
+      expected: record.value,
+      encoded: encoded.value,
+      comparison: options.compare ?? "bytes"
+    }),
+    ...compareObjects("headers", {
+      expected: textHeaders(record.headers ?? {}),
+      encoded: textHeaders(encoded.headers),
+      ignored: options.ignoreHeaders ?? []
+    }),
+    ...timestamp === void 0 || timestamp === record.timestamp ? [] : [`timestamp: expected ${record.timestamp}, encoded ${timestamp}`]
+  ];
+}
+function textHeaders(headers) {
+  return Object.fromEntries(
+    Object.entries(headers).map(([name, value]) => [
+      name,
+      toBuffer(Array.isArray(value) ? value.at(-1) : value).toString(
+        "utf8"
+      )
+    ])
+  );
+}
+function delivered(record) {
+  return {
+    topic: record.topic,
+    partition: record.partition ?? 0,
+    offset: record.offset ?? "0",
+    key: record.key === null ? null : toBuffer(record.key),
+    value: record.value === null ? null : toBuffer(record.value),
+    headers: Object.fromEntries(
+      Object.entries(record.headers ?? {}).map(([name, value]) => [name, toBuffer(value)])
+    ),
+    ...record.timestamp === void 0 ? {} : { timestamp: record.timestamp }
+  };
+}
+async function rabbitMqCodecMismatches(options, testCase) {
+  const { message } = testCase;
+  const encoding = testCase.only === "decode" ? { mismatches: [] } : await attempt("encode", () => options.encode(testCase.envelope));
+  const encoded = encoding.result;
+  const decoding = testCase.only === "encode" ? { mismatches: [] } : await attempt("decode", () => options.decode(delivered2(message)));
+  return [
+    ...encoding.mismatches,
+    ...encoded === void 0 ? [] : compareMessages(options, { message, encoded }),
+    ...decoding.mismatches,
+    ...decoding.result === void 0 ? [] : compareDecoded(testCase.decoded ?? testCase.envelope, decoding.result)
+  ];
+}
+function rabbitMqCodecContract(name, options) {
+  describe(`${name} writes and reads the captured RabbitMQ messages`, () => {
+    it.each(options.cases.map((testCase) => [testCase.name, testCase]))(
+      "%s",
+      async (_name, testCase) => {
+        expect(await rabbitMqCodecMismatches(options, testCase)).toEqual([]);
+      }
+    );
+  });
+}
+function compareMessages(options, {
+  message,
+  encoded
+}) {
+  const { headers, ...properties } = encoded.options;
+  return [
+    ...compareObjects("properties", {
+      expected: message.properties ?? {},
+      encoded: properties,
+      ignored: options.ignoreProperties ?? []
+    }),
+    ...compareObjects("headers", {
+      expected: message.headers ?? {},
+      encoded: headers ?? {},
+      ignored: options.ignoreHeaders ?? []
+    }),
+    ...compareBodies("body", {
+      expected: message.body,
+      encoded: encoded.content,
+      comparison: options.compare ?? "bytes"
+    })
+  ];
+}
+function delivered2(message) {
+  return {
+    content: toBuffer(message.body),
+    fields: { routingKey: message.routingKey },
+    properties: { ...message.properties, headers: { ...message.headers } }
+  };
+}
 
-export { FakeClock, InMemoryTransport, at, createDelivery, createEnvelope, eventStoreContract };
+export { FakeClock, InMemoryTransport, at, createDelivery, createEnvelope, eventStoreContract, kafkaCodecContract, kafkaCodecMismatches, rabbitMqCodecContract, rabbitMqCodecMismatches };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map