Moar test coverage!

Author: cliffhall

bin/cjs/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types/enum"), exports);
+__exportStar(require("./types/pipe"), exports);
+__exportStar(require("./types/message"), exports);
+__exportStar(require("./plumbing"), exports);

bin/esm/index.js

@@ -0,0 +1,4 @@
+export * from "./types/enum";
+export * from "./types/pipe";
+export * from "./types/message";
+export * from "./plumbing";

bin/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./types/enum";
+export * from "./types/pipe";
+export * from "./types/message";
+export * from "./plumbing";

src/test/Junction.spec.ts

@@ -0,0 +1,117 @@
+import { Pipe, PipeListener, Junction } from "../plumbing";
+import {
+  IPipeFitting,
+  IPipeMessage,
+  PipeMessageType,
+  JunctionType,
+} from "../index";
+
+describe("Junction Test", () => {
+  test("Register, retrieve and remove INPUT pipe", () => {
+    const pipe: IPipeFitting = new Pipe();
+    const junction = new Junction();
+
+    const registered = junction.registerPipe({
+      name: "testInputPipe",
+      type: JunctionType.INPUT,
+      pipe,
+    });
+
+    expect(pipe).toBeInstanceOf(Pipe);
+    expect(junction).toBeInstanceOf(Junction);
+    expect(registered).toBe(true);
+
+    expect(junction.hasPipe("testInputPipe")).toBe(true);
+    expect(junction.hasInputPipe("testInputPipe")).toBe(true);
+    expect(junction.retrievePipe("testInputPipe")).toBe(pipe);
+
+    junction.removePipe("testInputPipe");
+    expect(junction.hasPipe("testInputPipe")).toBe(false);
+    expect(junction.hasInputPipe("testInputPipe")).toBe(false);
+    expect(junction.retrievePipe("testInputPipe")).toBeUndefined();
+  });
+
+  test("Register, retrieve and remove OUTPUT pipe", () => {
+    const pipe: IPipeFitting = new Pipe();
+    const junction = new Junction();
+
+    const registered = junction.registerPipe({
+      name: "testOutputPipe",
+      type: JunctionType.OUTPUT,
+      pipe,
+    });
+
+    expect(pipe).toBeInstanceOf(Pipe);
+    expect(junction).toBeInstanceOf(Junction);
+    expect(registered).toBe(true);
+
+    expect(junction.hasPipe("testOutputPipe")).toBe(true);
+    expect(junction.hasOutputPipe("testOutputPipe")).toBe(true);
+    expect(junction.retrievePipe("testOutputPipe")).toBe(pipe);
+
+    junction.removePipe("testOutputPipe");
+    expect(junction.hasPipe("testOutputPipe")).toBe(false);
+    expect(junction.hasOutputPipe("testOutputPipe")).toBe(false);
+    expect(junction.retrievePipe("testOutputPipe")).toBeUndefined();
+  });
+
+  test("Add PipeListener to INPUT pipe and receive message", () => {
+    const pipe: IPipeFitting = new Pipe();
+    const junction = new Junction();
+    const messagesReceived: IPipeMessage[] = [];
+    const message: IPipeMessage = {
+      type: PipeMessageType.NORMAL,
+      header: { testVal: 1 },
+    };
+
+    const registered = junction.registerPipe({
+      name: "testInputPipe",
+      type: JunctionType.INPUT,
+      pipe,
+    });
+
+    const listenerAdded = junction.addPipeListener("testInputPipe", (m) => {
+      messagesReceived.push(m);
+    });
+
+    const sent = pipe.write(message);
+
+    expect(pipe).toBeInstanceOf(Pipe);
+    expect(junction).toBeInstanceOf(Junction);
+    expect(registered).toBe(true);
+    expect(listenerAdded).toBe(true);
+    expect(sent).toBe(true);
+    expect(messagesReceived.length).toBe(1);
+    expect(messagesReceived.pop()).toBe(message);
+  });
+
+  test("Send message on OUTPUT pipe via Junction", () => {
+    const pipe: IPipeFitting = new Pipe();
+    const messagesReceived: IPipeMessage[] = [];
+    const listenerAdded = pipe.connect(
+      new PipeListener((m) => messagesReceived.push(m)),
+    );
+
+    const junction = new Junction();
+    const message: IPipeMessage = {
+      type: PipeMessageType.NORMAL,
+      header: { testVal: 1 },
+    };
+
+    const registered = junction.registerPipe({
+      name: "testOutputPipe",
+      type: JunctionType.OUTPUT,
+      pipe,
+    });
+
+    const sent = junction.sendMessage("testOutputPipe", message);
+
+    expect(pipe).toBeInstanceOf(Pipe);
+    expect(junction).toBeInstanceOf(Junction);
+    expect(registered).toBe(true);
+    expect(listenerAdded).toBe(true);
+    expect(sent).toBe(true);
+    expect(messagesReceived.length).toBe(1);
+    expect(messagesReceived.pop()).toBe(message);
+  });
+});

src/test/Message.spec.ts

@@ -0,0 +1,47 @@
+import { IPipeMessage } from "../types/message";
+import { PipeMessageType } from "../types/enum";
+
+/**
+ * Test the Message shape (IPipeMessage).
+ */
+describe("Message Test", () => {
+  test("Constructor shape and property access", () => {
+    // create a message with complete fields
+    const message: IPipeMessage = {
+      type: PipeMessageType.NORMAL,
+      header: { testProp: "testval" },
+      body: { testAtt: "Hello" },
+      priority: 1,
+    };
+
+    // assertions
+    expect(message.type).toBe(PipeMessageType.NORMAL);
+    expect((message.header as any).testProp).toBe("testval");
+    expect((message.body as any).testAtt).toBe("Hello");
+    expect(message.priority).toBe(1);
+  });
+
+  test("Default (omitted) priority is undefined", () => {
+    // Create a message with minimum fields
+    const message: IPipeMessage = { type: PipeMessageType.NORMAL };
+
+    // priority should be undefined unless set
+    expect(message.priority).toBeUndefined();
+  });
+
+  test("Mutating fields behaves like setters/getters", () => {
+    // create a minimal message
+    const message: IPipeMessage = { type: PipeMessageType.NORMAL };
+
+    // mutate remaining fields (analogous to setters)
+    message.header = { testProp: "testval" } as any;
+    message.body = { testAtt: "Hello" } as any;
+    message.priority = 3;
+
+    // assertions
+    expect(message.type).toBe(PipeMessageType.NORMAL);
+    expect((message.header as any).testProp).toBe("testval");
+    expect((message.body as any).testAtt).toBe("Hello");
+    expect(message.priority).toBe(3);
+  });
+});

src/test/PipeListener.spec.ts

@@ -0,0 +1,74 @@
+import { Pipe, PipeListener } from "../plumbing";
+import { IPipeFitting, IPipeMessage, PipeMessageType } from "../index";
+
+/**
+ * Test the PipeListener class.
+ */
+describe("PipeListener Test", () => {
+  test("PipeListener.connect returns false and disconnect returns undefined", () => {
+    const listener: PipeListener = new PipeListener(() => void 0);
+    const connected = listener.connect(new Pipe());
+    expect(connected).toBe(false);
+    expect(listener.disconnect()).toBeUndefined();
+  });
+
+  test("Connect a PipeListener to a Pipe", () => {
+    // create pipe and listener
+    const pipe: IPipeFitting = new Pipe();
+    const listener: PipeListener = new PipeListener(() => void 0);
+
+    // connect the listener to the pipe
+    const success: boolean = pipe.connect(listener);
+
+    // test assertions
+    expect(pipe).toBeInstanceOf(Pipe);
+    expect(success).toBe(true);
+  });
+
+  test("Receive a message via PipeListener", () => {
+    let messageReceived: IPipeMessage | undefined;
+
+    // create a message
+    const messageToSend: IPipeMessage = {
+      type: PipeMessageType.NORMAL,
+      header: { testProp: "testval" },
+      body: { testAtt: "Hello" },
+      priority: 0,
+    };
+
+    // create pipe and listener
+    const pipe: IPipeFitting = new Pipe();
+    const listener: PipeListener = new PipeListener((msg) => {
+      messageReceived = msg;
+    });
+
+    // connect the listener to the pipe and write the message
+    const connected: boolean = pipe.connect(listener);
+    const written: boolean = pipe.write(messageToSend);
+
+    // test assertions
+    expect(pipe).toBeInstanceOf(Pipe);
+    expect(connected).toBe(true);
+    expect(written).toBe(true);
+    expect(messageReceived).toBeDefined();
+    expect((messageReceived as IPipeMessage).type).toBe(PipeMessageType.NORMAL);
+    expect(((messageReceived as IPipeMessage).header as any).testProp).toBe(
+      "testval",
+    );
+    expect(((messageReceived as IPipeMessage).body as any).testAtt).toBe(
+      "Hello",
+    );
+    expect((messageReceived as IPipeMessage).priority).toBe(0);
+  });
+
+  test("Write returns false when callback is undefined", () => {
+    // Force an undefined callback using a cast
+    const listener = new PipeListener((() => void 0) as any) as any;
+    listener.callback = undefined;
+
+    const success = (listener as PipeListener).write({
+      type: PipeMessageType.NORMAL,
+    });
+    expect(success).toBe(false);
+  });
+});

src/test/Queue.spec.ts

@@ -0,0 +1,127 @@
+import { Pipe, Queue, PipeListener } from "../plumbing";
+import {
+  IPipeFitting,
+  IPipeMessage,
+  PipeMessageType,
+  QueueControlMessageType,
+} from "../index";
+
+describe("Queue Test", () => {
+  test("Connect input and output pipes to a Queue", () => {
+    const pipe1: IPipeFitting = new Pipe();
+    const pipe2: IPipeFitting = new Pipe();
+    const queue: Queue = new Queue();
+
+    const connectedInput = pipe1.connect(queue);
+    const connectedOutput = queue.connect(pipe2);
+
+    expect(pipe1).toBeInstanceOf(Pipe);
+    expect(pipe2).toBeInstanceOf(Pipe);
+    expect(queue).toBeInstanceOf(Queue);
+    expect(connectedInput).toBe(true);
+    expect(connectedOutput).toBe(true);
+  });
+
+  test("Write multiple messages then FLUSH (FIFO)", () => {
+    const messagesReceived: IPipeMessage[] = [];
+
+    const message1: IPipeMessage = {
+      type: PipeMessageType.NORMAL,
+      header: { testProp: 1 },
+    };
+    const message2: IPipeMessage = {
+      type: PipeMessageType.NORMAL,
+      header: { testProp: 2 },
+    };
+    const message3: IPipeMessage = {
+      type: PipeMessageType.NORMAL,
+      header: { testProp: 3 },
+    };
+
+    const flush: IPipeMessage = { type: QueueControlMessageType.FLUSH } as any;
+
+    const queue: Queue = new Queue(new PipeListener((m) => messagesReceived.push(m)));
+
+    const message1written = queue.write(message1);
+    const message2written = queue.write(message2);
+    const message3written = queue.write(message3);
+
+    expect(message1written).toBe(true);
+    expect(message2written).toBe(true);
+    expect(message3written).toBe(true);
+
+    // nothing received yet (enqueued)
+    expect(messagesReceived.length).toBe(0);
+
+    const flushWritten = queue.write(flush);
+    expect(flushWritten).toBe(true);
+
+    // all 3 received FIFO and identity preserved
+    expect(messagesReceived.length).toBe(3);
+    const received1 = messagesReceived.shift() as IPipeMessage;
+    const received2 = messagesReceived.shift() as IPipeMessage;
+    const received3 = messagesReceived.shift() as IPipeMessage;
+    expect(received1).toBe(message1);
+    expect(received2).toBe(message2);
+    expect(received3).toBe(message3);
+  });
+
+  test("SORT by priority then FIFO switch", () => {
+    const messagesReceived: IPipeMessage[] = [];
+
+    const message1: IPipeMessage = {
+      type: PipeMessageType.NORMAL,
+      priority: 2, // MEDIUM
+    };
+    const message2: IPipeMessage = {
+      type: PipeMessageType.NORMAL,
+      priority: 3, // LOW
+    };
+    const message3: IPipeMessage = {
+      type: PipeMessageType.NORMAL,
+      priority: 1, // HIGH
+    };
+
+    const queue: Queue = new Queue(new PipeListener((m) => messagesReceived.push(m)));
+
+    // begin sort-by-priority mode
+    const sortWritten = queue.write({ type: QueueControlMessageType.SORT } as any);
+
+    // write messages and flush
+    const w1 = queue.write(message1);
+    const w2 = queue.write(message2);
+    const w3 = queue.write(message3);
+    const flushWritten = queue.write({ type: QueueControlMessageType.FLUSH } as any);
+
+    expect(sortWritten).toBe(true);
+    expect(w1 && w2 && w3 && flushWritten).toBe(true);
+    expect(messagesReceived.length).toBe(3);
+
+    const r1 = messagesReceived.shift() as IPipeMessage;
+    const r2 = messagesReceived.shift() as IPipeMessage;
+    const r3 = messagesReceived.shift() as IPipeMessage;
+
+    // ascending numeric priority: 1 (HIGH), 2 (MED), 3 (LOW)
+    expect((r1.priority as number) < (r2.priority as number)).toBe(true);
+    expect((r2.priority as number) < (r3.priority as number)).toBe(true);
+    expect(r1).toBe(message3);
+    expect(r2).toBe(message1);
+    expect(r3).toBe(message2);
+
+    // switch back to FIFO
+    const fifoWritten = queue.write({ type: QueueControlMessageType.FIFO } as any);
+    const w1b = queue.write(message1);
+    const w2b = queue.write(message2);
+    const w3b = queue.write(message3);
+    const flushWrittenB = queue.write({ type: QueueControlMessageType.FLUSH } as any);
+
+    expect(fifoWritten && w1b && w2b && w3b && flushWrittenB).toBe(true);
+    expect(messagesReceived.length).toBe(3);
+    const rb1 = messagesReceived.shift() as IPipeMessage;
+    const rb2 = messagesReceived.shift() as IPipeMessage;
+    const rb3 = messagesReceived.shift() as IPipeMessage;
+    expect(rb1).toBe(message1);
+    expect(rb2).toBe(message2);
+    expect(rb3).toBe(message3);
+  });
+});