tapeworm 0.5.0 → 0.6.0

package/test/event_stream.ts

@@ -0,0 +1,160 @@
+import Promise from "bluebird";
+import { v4 as uuid } from "uuid";
+import { describe, expect, it } from "vitest";
+import EventStore from "..";
+import EventStream from "../src/event_stream";
+
+describe("event_stream", () => {
+  describe("#openStream", () => {
+    it("should return 0 commits for new stream", async () => {
+      const es = new EventStore();
+      const stream = await es.openPartition("location").call("openStream", "1");
+      expect(stream.getCommittedEvents()).toHaveLength(0);
+    });
+  });
+
+  describe("#commit", () => {
+    it("should do nothing if nothing has been appended", async () => {
+      const es = new EventStore();
+      const stream = await es.openPartition("location").call("openStream", "1");
+      stream.commit(uuid());
+      expect(stream.getCommittedEvents()).toHaveLength(0);
+    });
+
+    it("should call commit on partition", () => {
+      let called = false;
+      const mockPartition = {
+        append: (commit, callback) => {
+          called = true;
+          return Promise.resolve().nodeify(callback);
+        },
+        _queryStream: (streamId, callback) => {
+          return Promise.resolve([]).nodeify(callback);
+        },
+      };
+
+      const stream = new EventStream(mockPartition, "11");
+      stream.append({ event: "123" });
+      stream.commit(uuid());
+
+      expect(called).toBe(true);
+    });
+
+    it("should keep track of uncommitted events", async () => {
+      const es = new EventStore();
+      const stream = await es.openPartition("location").call("openStream", "1");
+
+      stream.append({ event: "123" });
+      expect(stream.getUncommittedEvents()).toHaveLength(1);
+    });
+
+    it("should move uncommitted events to committed on commit", async () => {
+      const es = new EventStore();
+      const stream = await es.openPartition("location").call("openStream", "1");
+
+      stream.append({ event: "123" });
+      await stream.commit(uuid());
+
+      expect(stream.getUncommittedEvents()).toHaveLength(0);
+      expect(stream.getCommittedEvents()).toHaveLength(1);
+    });
+
+    it("two events becomes one commit", async () => {
+      const es = new EventStore();
+      const stream = await es.openPartition("location").call("openStream", "1");
+
+      stream.append({ event: "123" });
+      stream.append({ event: "999" });
+      await stream.commit(uuid());
+
+      expect(stream.getCommittedEvents()).toHaveLength(2);
+      expect(stream._commitSequence).toBe(0);
+    });
+
+    it("two commits gets increasing commit sequence", async () => {
+      const es = new EventStore();
+      const stream = await es.openPartition("location").call("openStream", "1");
+
+      stream.append({ event: "123" });
+      stream.append({ event: "999" });
+      await stream.commit(uuid());
+
+      stream.append({ event: "666" });
+      stream.append({ event: "777" });
+      await stream.commit(uuid());
+
+      expect(stream.getCommittedEvents()).toHaveLength(4);
+      expect(stream._commitSequence).toBe(1);
+    });
+
+    it("event stream writeOnly", async () => {
+      const es = new EventStore();
+      const partition = await es.openPartition("location");
+      const stream = await partition.openStream("1", true);
+
+      stream.append({ event: "123" });
+      await stream.commit(uuid());
+
+      expect(stream._commitSequence).toBe(0);
+      stream.append({ event: "666" });
+      stream.append({ event: "777" });
+      await stream.commit(uuid());
+
+      expect(stream._commitSequence).toBe(1);
+    });
+
+    it("committed events should have increasing version", async () => {
+      const es = new EventStore();
+      const stream = await es.openPartition("location").call("openStream", "1");
+
+      stream.append({ event: "123" });
+      stream.append({ event: "999" });
+      await stream.commit(uuid());
+
+      stream.append({ event: "666" });
+      stream.append({ event: "777" });
+      await stream.commit(uuid());
+
+      expect(stream.getCommittedEvents()[3].version).toBe(3);
+      expect(stream._version).toBe(4);
+    });
+
+    it("committed events should have increasing version (writeOnly)", async () => {
+      const es = new EventStore();
+      const partition = await es.openPartition("location");
+      const stream = await partition.openStream("1", true);
+
+      stream.append({ event: "123" });
+      stream.append({ event: "999" });
+      await stream.commit(uuid());
+
+      stream.append({ event: "666" });
+      stream.append({ event: "777" });
+      await stream.commit(uuid());
+
+      expect(stream._version).toBe(4);
+    });
+
+    it("published events should have increasing version", async () => {
+      let commitCount = 0;
+
+      const es = new EventStore(null, (commit) => {
+        expect(commit.events[0]).toHaveProperty("version");
+        commitCount++;
+      });
+
+      const stream = await es.openPartition("location").call("openStream", "1");
+
+      stream.append({ event: "123" });
+      stream.append({ event: "999" });
+      await stream.commit(uuid());
+
+      stream.append({ event: "666" });
+      stream.append({ event: "777" });
+      await stream.commit(uuid());
+
+      expect(stream.getCommittedEvents()[1].version).toBe(1);
+      expect(commitCount).toBe(2);
+    });
+  });
+});

package/test/persistence/inmemory.ts

@@ -0,0 +1,139 @@
+import Promise from "bluebird";
+import { v4 as uuid } from "uuid";
+import { describe, expect, it } from "vitest";
+import Event from "../../src/event";
+import Commit from "../../src/persistence/commit";
+import Store from "../../src/persistence/inmemory/inmemory_persistence";
+
+describe("inmemory_persistence", () => {
+  describe("#commit", () => {
+    it("should accept a commit and store it", async () => {
+      const store = new Store();
+      const partition = await store.openPartition("1");
+      const events = [new Event(uuid(), "type1", { test: 11 })];
+      const commit = new Commit(uuid(), "master", "1", 0, events);
+
+      await partition.append(commit);
+      const x = await partition.queryAll();
+      expect(x).toHaveLength(1);
+    });
+
+    it("commit in one stream is not visible in other", async () => {
+      const store = new Store();
+      const partition = await store.openPartition("1");
+
+      let events = [new Event(uuid(), "type1", { test: 11 })];
+      let commit = new Commit(uuid(), "master", "1", 0, events);
+      partition.append(commit);
+
+      events = [new Event(uuid(), "type2", { test: 22 })];
+      commit = new Commit(uuid(), "master", "2", 0, events);
+      partition.append(commit);
+
+      const [r1, r2] = await Promise.all([partition.queryStream("1"), partition.queryStream("2")]);
+
+      expect(r1).toHaveLength(1);
+      expect(r2).toHaveLength(1);
+    });
+
+    it("two commits in one stream are visible", async () => {
+      const store = new Store();
+      const partition = await store.openPartition("1");
+
+      let events = [new Event(uuid(), "type1", { test: 11 })];
+      let commit = new Commit(uuid(), "master", "1", 0, events);
+      partition.append(commit);
+
+      events = [new Event(uuid(), "type2", { test: 22 })];
+      commit = new Commit(uuid(), "master", "1", 1, events);
+      partition.append(commit);
+
+      const res = await partition.queryAll();
+      expect(res).toHaveLength(2);
+    });
+
+    it("should skip events", async () => {
+      const store = new Store();
+      const partition = await store.openPartition("1");
+
+      let events = [new Event(uuid(), "type1", { test: 11 }), new Event(uuid(), "type1", { test: 12 })];
+      let commit = new Commit(uuid(), "master", "1", 0, events);
+      partition.append(commit);
+
+      events = [new Event(uuid(), "type2", { test: 22 })];
+      commit = new Commit(uuid(), "master", "1", 1, events);
+      partition.append(commit);
+
+      const res = await partition.queryStream("1", 2);
+      expect(res).toHaveLength(1);
+    });
+
+    it("should skip events and split commit if inbetween", async () => {
+      const store = new Store();
+      const partition = await store.openPartition("1");
+
+      let events = [new Event(uuid(), "type1", { test: 11 }), new Event(uuid(), "type1", { test: 12 })];
+      let commit = new Commit(uuid(), "master", "1", 0, events);
+      partition.append(commit);
+
+      events = [new Event(uuid(), "type2", { test: 22 })];
+      commit = new Commit(uuid(), "master", "1", 1, events);
+      partition.append(commit);
+
+      const res = await partition.queryStream("1", 1);
+      expect(res).toHaveLength(2);
+      expect(res[0].events).toHaveLength(1);
+    });
+  });
+  describe("#concurrency", () => {
+    it("same commit sequence twice should throw", async () => {
+      const store = new Store();
+      const partition = await store.openPartition("1");
+
+      const events = [new Event(uuid(), "type1", { test: 11 })];
+      const commit = new Commit(uuid(), "master", "1", 0, events);
+      const commit2 = new Commit(uuid(), "master", "1", 0, events);
+
+      await expect(async () => await Promise.all(partition.append(commit), partition.append(commit2))).rejects.toThrow("Concurrency error on stream 1");
+    });
+  });
+
+  describe("#duplicateEvents", () => {
+    it("same commit twice should throw", async () => {
+      const store = new Store();
+      const partition = await store.openPartition("1");
+
+      const events = [new Event(uuid(), "type1", { test: 11 })];
+      const commit = new Commit(uuid(), "master", "1", 0, events);
+
+      await partition.append(commit);
+      await expect(async () => partition.append(commit)).rejects.toThrow(`Duplicate commit of ${commit.id}`);
+    });
+  });
+
+  describe("#partition", () => {
+    it("getting the same partition twice should return same instance", async () => {
+      const store = new Store();
+      const [p1, p2] = await Promise.all([store.openPartition("1"), store.openPartition("1")]);
+      expect(p1).toBe(p2);
+    });
+
+    it("not indicating partition name should give master partition", async () => {
+      const store = new Store();
+      const [p1, p2] = await Promise.all([store.openPartition(), store.openPartition("master")]);
+      expect(p1).toBe(p2);
+    });
+  });
+
+  describe("#storeSnapshot", () => {
+    it("should return previously stored snapshot", async () => {
+      const store = new Store();
+      const part = await store.openPartition("1");
+
+      const snapshot = await part.storeSnapshot("stream1", { iAmSnapshot: true }, 10);
+      const newSnapshot = await part.loadSnapshot("stream1");
+
+      expect(newSnapshot).toBe(snapshot);
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": ".",
+    "declaration": true,
+    "declarationMap": true,
+    "ignoreDeprecations": "6.0",
+    "types": ["node"]
+  },
+  "include": ["src/**/*", "index.ts"],
+  "exclude": ["test/**/*", "dist/**/*"]
+}

package/vitest.config.ts

@@ -0,0 +1,13 @@
+import { defineConfig } from "vitest/config";
+import path from "node:path";
+
+export default defineConfig({
+  test: {
+    include: ["**/*.{test,spec}.?[jt]s", "test/**/*.[jt]s"],
+  },
+  resolve: {
+    alias: {
+      tapeworm: path.resolve(__dirname, "index.ts"),
+    },
+  },
+});

package/.eslintrc

@@ -1,4 +0,0 @@
-{
-    
-	"extends": "airbnb-es5"
-}

package/.travis.yml

@@ -1,4 +0,0 @@
-language: node_js
-node_js:
-  - "0.11"
-  - "0.10"