@daiso-tech/core
Version:
The library offers flexible, framework-agnostic solutions for modern web applications, built on adaptable components that integrate seamlessly with popular frameworks like Next Js.
823 lines • 32.4 kB
JavaScript
/**
* @module EventBus
*/
import {} from "vitest";
import { BaseEvent, } from "../../../event-bus/contracts/_module-exports.js";
import {} from "../../../utilities/_module-exports.js";
import { TimeSpan } from "../../../utilities/_module-exports.js";
import { LazyPromise } from "../../../async/_module-exports.js";
import { Serde } from "../../../serde/implementations/derivables/_module-exports.js";
import { NoOpSerdeAdapter } from "../../../serde/implementations/adapters/_module-exports.js";
/**
* The `eventBusTestSuite` function simplifies the process of testing your custom implementation of {@link IEventBus | `IEventBus`} with vitest.
*
* IMPORT_PATH: `"@daiso-tech/core/event-bus/test-utilities"`
* @group TestUtilities
*/
export function eventBusTestSuite(settings) {
const { expect, serde = new Serde(new NoOpSerdeAdapter()), test, describe, createEventBus, beforeEach, } = settings;
const TTL = TimeSpan.fromMilliseconds(50);
class AddEvent extends BaseEvent {
}
class SubEvent extends BaseEvent {
}
serde.registerEvent(AddEvent).registerEvent(SubEvent);
let eventBus;
beforeEach(async () => {
eventBus = await createEventBus();
});
describe("method: addListener, removeListener, dispatch", () => {
describe("Should be null when listener is added and event is not triggered", () => {
test("Object literal listener", async () => {
const listener = {
result: null,
invoke(event) {
this.result = event;
},
};
await eventBus.addListener(AddEvent, listener);
expect(listener.result).toBeNull();
await eventBus.removeListener(AddEvent, listener);
});
test("Class instance listener", async () => {
class Listener {
result = null;
invoke(event) {
this.result = event;
}
}
const listener = new Listener();
await eventBus.addListener(AddEvent, listener);
expect(listener.result).toBeNull();
await eventBus.removeListener(AddEvent, listener);
});
test("Function listener", async () => {
let result = null;
const listener = (event) => {
result = event;
};
await eventBus.addListener(AddEvent, listener);
expect(result).toBeNull();
await eventBus.removeListener(AddEvent, listener);
});
});
describe("Should be AddEvent when listener is added and event is triggered", () => {
test("Object literal listener", async () => {
const listener = {
result: null,
invoke(event) {
this.result = event;
},
};
await eventBus.addListener(AddEvent, listener);
const event = new AddEvent({
a: 1,
b: 2,
});
await eventBus.dispatch(event);
await LazyPromise.delay(TTL);
expect(listener.result).toEqual(event);
expect(listener.result).toBeInstanceOf(AddEvent);
await eventBus.removeListener(AddEvent, listener);
});
test("Class instance listener", async () => {
class Listener {
result = null;
invoke(event) {
this.result = event;
}
}
const listener = new Listener();
await eventBus.addListener(AddEvent, listener);
const event = new AddEvent({
a: 1,
b: 2,
});
await eventBus.dispatch(event);
await LazyPromise.delay(TTL);
expect(listener.result).toEqual(event);
expect(listener.result).toBeInstanceOf(AddEvent);
await eventBus.removeListener(AddEvent, listener);
});
test("Function listener", async () => {
let result = null;
const listener = (event) => {
result = event;
};
await eventBus.addListener(AddEvent, listener);
const event = new AddEvent({
a: 1,
b: 2,
});
await eventBus.dispatch(event);
await LazyPromise.delay(TTL);
expect(result).toEqual(event);
expect(result).toBeInstanceOf(AddEvent);
await eventBus.removeListener(AddEvent, listener);
});
});
describe("Should be null when listener is removed and event is triggered", () => {
test("Object literal listener", async () => {
const listener = {
result: null,
invoke(event) {
this.result = event;
},
};
await eventBus.addListener(AddEvent, listener);
await eventBus.removeListener(AddEvent, listener);
const event = new AddEvent({
a: 1,
b: 2,
});
await eventBus.dispatch(event);
await LazyPromise.delay(TTL);
expect(listener.result).toBeNull();
});
test("Class instance listener", async () => {
class Listener {
result = null;
invoke(event) {
this.result = event;
}
}
const listener = new Listener();
await eventBus.addListener(AddEvent, listener);
await eventBus.removeListener(AddEvent, listener);
const event = new AddEvent({
a: 1,
b: 2,
});
await eventBus.dispatch(event);
await LazyPromise.delay(TTL);
expect(listener.result).toBeNull();
});
test("Function listener", async () => {
let result = null;
const listener = (event) => {
result = event;
};
await eventBus.addListener(AddEvent, listener);
await eventBus.removeListener(AddEvent, listener);
const event = new AddEvent({
a: 1,
b: 2,
});
await eventBus.dispatch(event);
await LazyPromise.delay(TTL);
expect(result).toBeNull();
});
});
});
describe("method: subscribe, dispatch", () => {
describe("Should be null when listener is added and event is not triggered", () => {
test("Object literal listener", async () => {
const listener = {
result: null,
invoke(event) {
this.result = event;
},
};
const unsubscribe = await eventBus.subscribe(AddEvent, listener);
expect(listener.result).toBeNull();
await unsubscribe();
});
test("Class instance listener", async () => {
class Listener {
result = null;
invoke(event) {
this.result = event;
}
}
const listener = new Listener();
const unsubscribe = await eventBus.subscribe(AddEvent, listener);
expect(listener.result).toBeNull();
await unsubscribe();
});
test("Function listener", async () => {
let result = null;
const listener = (event) => {
result = event;
};
const unsubscribe = await eventBus.subscribe(AddEvent, listener);
expect(result).toBeNull();
await unsubscribe();
});
});
describe("Should be AddEvent when listener is added and event is triggered", () => {
test("Object literal listener", async () => {
const listener = {
result: null,
invoke(event) {
this.result = event;
},
};
const unsubscribe = await eventBus.subscribe(AddEvent, listener);
const event = new AddEvent({
a: 1,
b: 2,
});
await eventBus.dispatch(event);
await LazyPromise.delay(TTL);
expect(listener.result).toEqual(event);
expect(listener.result).toBeInstanceOf(AddEvent);
await unsubscribe();
});
test("Class instance listener", async () => {
class Listener {
result = null;
invoke(event) {
this.result = event;
}
}
const listener = new Listener();
const unsubscribe = await eventBus.subscribe(AddEvent, listener);
const event = new AddEvent({
a: 1,
b: 2,
});
await eventBus.dispatch(event);
await LazyPromise.delay(TTL);
expect(listener.result).toEqual(event);
expect(listener.result).toBeInstanceOf(AddEvent);
await unsubscribe();
});
test("Function listener", async () => {
let result = null;
const listener = (event) => {
result = event;
};
const unsubscribe = await eventBus.subscribe(AddEvent, listener);
const event = new AddEvent({
a: 1,
b: 2,
});
await eventBus.dispatch(event);
await LazyPromise.delay(TTL);
expect(result).toEqual(event);
expect(result).toBeInstanceOf(AddEvent);
await unsubscribe();
});
});
describe("Should be null when listener is removed by unsubscribe and event is triggered", () => {
test("Object literal listener", async () => {
const listener = {
result: null,
invoke(event) {
this.result = event;
},
};
const unsubscribe = await eventBus.subscribe(AddEvent, listener);
await unsubscribe();
const event = new AddEvent({
a: 1,
b: 2,
});
await eventBus.dispatch(event);
await LazyPromise.delay(TTL);
expect(listener.result).toBeNull();
});
test("Class instance listener", async () => {
class Listener {
result = null;
invoke(event) {
this.result = event;
}
}
const listener = new Listener();
const unsubscribe = await eventBus.subscribe(AddEvent, listener);
await unsubscribe();
const event = new AddEvent({
a: 1,
b: 2,
});
await eventBus.dispatch(event);
await LazyPromise.delay(TTL);
expect(listener.result).toBeNull();
});
test("Function listener", async () => {
let result = null;
const listener = (event) => {
result = event;
};
const unsubscribe = await eventBus.subscribe(AddEvent, listener);
await unsubscribe();
const event = new AddEvent({
a: 1,
b: 2,
});
await eventBus.dispatch(event);
await LazyPromise.delay(TTL);
expect(result).toBeNull();
});
});
describe("Should be null when listener is removed by removeListener and event is triggered", () => {
test("Object literal listener", async () => {
const listener = {
result: null,
invoke(event) {
this.result = event;
},
};
await eventBus.subscribe(AddEvent, listener);
await eventBus.removeListener(AddEvent, listener);
const event = new AddEvent({
a: 1,
b: 2,
});
await eventBus.dispatch(event);
await LazyPromise.delay(TTL);
expect(listener.result).toBeNull();
});
test("Class instance listener", async () => {
class Listener {
result = null;
invoke(event) {
this.result = event;
}
}
const listener = new Listener();
await eventBus.subscribe(AddEvent, listener);
await eventBus.removeListener(AddEvent, listener);
const event = new AddEvent({
a: 1,
b: 2,
});
await eventBus.dispatch(event);
await LazyPromise.delay(TTL);
expect(listener.result).toBeNull();
});
test("Function listener", async () => {
let result = null;
const listener = (event) => {
result = event;
};
await eventBus.subscribe(AddEvent, listener);
await eventBus.removeListener(AddEvent, listener);
const event = new AddEvent({
a: 1,
b: 2,
});
await eventBus.dispatch(event);
await LazyPromise.delay(TTL);
expect(result).toBeNull();
});
});
});
describe("method: subscribeOnce", () => {
describe("Should be null when listener added and event is not triggered", () => {
test("Object literal listener", async () => {
const listener = {
result: null,
invoke(event) {
this.result = event;
},
};
await eventBus.subscribeOnce(AddEvent, listener);
expect(listener.result).toBeNull();
});
test("Class instance listener", async () => {
class Listener {
result = null;
invoke(event) {
this.result = event;
}
}
const listener = new Listener();
await eventBus.subscribeOnce(AddEvent, listener);
expect(listener.result).toBeNull();
});
test("Function listener", async () => {
let result = null;
const listener = (event) => {
result = event;
};
await eventBus.subscribeOnce(AddEvent, listener);
expect(result).toBeNull();
});
});
describe("Should be AddEvent when listener added and event is triggered", () => {
test("Object literal listener", async () => {
const listener = {
result: null,
invoke(event) {
this.result = event;
},
};
await eventBus.subscribeOnce(AddEvent, listener);
const event = new AddEvent({
a: 1,
b: 2,
});
await eventBus.dispatch(event);
await LazyPromise.delay(TTL);
expect(listener.result).toEqual(event);
expect(listener.result).toBeInstanceOf(AddEvent);
});
test("Class instance listener", async () => {
class Listener {
result = null;
invoke(event) {
this.result = event;
}
}
const listener = new Listener();
await eventBus.subscribeOnce(AddEvent, listener);
const event = new AddEvent({
a: 1,
b: 2,
});
await eventBus.dispatch(event);
await LazyPromise.delay(TTL);
expect(listener.result).toEqual(event);
expect(listener.result).toBeInstanceOf(AddEvent);
});
test("Function listener", async () => {
let result = null;
const listener = (event) => {
result = event;
};
await eventBus.subscribeOnce(AddEvent, listener);
const event = new AddEvent({
a: 1,
b: 2,
});
await eventBus.dispatch(event);
await LazyPromise.delay(TTL);
expect(result).toEqual(event);
expect(result).toBeInstanceOf(AddEvent);
});
});
describe("Should only listen for event once", () => {
test("Object literal listener", async () => {
const listener = {
i: 0,
invoke(_event) {
this.i++;
},
};
await eventBus.subscribeOnce(AddEvent, listener);
const event = new AddEvent({
a: 1,
b: 2,
});
await eventBus.dispatch(event);
await eventBus.dispatch(event);
await LazyPromise.delay(TTL);
expect(listener.i).toBe(1);
});
test("Class instance listener", async () => {
class Listener {
i = 0;
invoke(_event) {
this.i++;
}
}
const listener = new Listener();
await eventBus.subscribeOnce(AddEvent, listener);
const event = new AddEvent({
a: 1,
b: 2,
});
await eventBus.dispatch(event);
await eventBus.dispatch(event);
await LazyPromise.delay(TTL);
expect(listener.i).toBe(1);
});
test("Function listener", async () => {
let i = 0;
const listener = () => {
i++;
};
await eventBus.subscribeOnce(AddEvent, listener);
const event = new AddEvent({
a: 1,
b: 2,
});
await eventBus.dispatch(event);
await eventBus.dispatch(event);
await LazyPromise.delay(TTL);
expect(i).toBe(1);
});
});
describe("Should be null when listener is removed by unsubscribe function and event is triggered", () => {
test("Object literal listener", async () => {
const listener = {
result: null,
invoke(event) {
this.result = event;
},
};
const unsubscribe = await eventBus.subscribeOnce(AddEvent, listener);
await unsubscribe();
const event = new AddEvent({
a: 1,
b: 2,
});
await eventBus.dispatch(event);
await LazyPromise.delay(TTL);
expect(listener.result).toBeNull();
});
test("Class instance listener", async () => {
class Listener {
result = null;
invoke(event) {
this.result = event;
}
}
const listener = new Listener();
const unsubscribe = await eventBus.subscribeOnce(AddEvent, listener);
await unsubscribe();
const event = new AddEvent({
a: 1,
b: 2,
});
await eventBus.dispatch(event);
await LazyPromise.delay(TTL);
expect(listener.result).toBeNull();
});
test("Function listener", async () => {
let result = null;
const listener = (event) => {
result = event;
};
const unsubscribe = await eventBus.subscribeOnce(AddEvent, listener);
await unsubscribe();
const event = new AddEvent({
a: 1,
b: 2,
});
await eventBus.dispatch(event);
await LazyPromise.delay(TTL);
expect(result).toBeNull();
});
});
describe("Should be null when listener is removed by removeListener method and event is triggered", () => {
test("Object literal listener", async () => {
const listener = {
result: null,
invoke(event) {
this.result = event;
},
};
await eventBus.subscribeOnce(AddEvent, listener);
await eventBus.removeListener(AddEvent, listener);
const event = new AddEvent({
a: 1,
b: 2,
});
await eventBus.dispatch(event);
await LazyPromise.delay(TTL);
expect(listener.result).toBeNull();
});
test("Class instance listener", async () => {
class Listener {
result = null;
invoke(event) {
this.result = event;
}
}
const listener = new Listener();
await eventBus.subscribeOnce(AddEvent, listener);
await eventBus.removeListener(AddEvent, listener);
const event = new AddEvent({
a: 1,
b: 2,
});
await eventBus.dispatch(event);
await LazyPromise.delay(TTL);
expect(listener.result).toBeNull();
});
test("Function listener", async () => {
let result = null;
const listener = (event) => {
result = event;
};
await eventBus.subscribeOnce(AddEvent, listener);
await eventBus.removeListener(AddEvent, listener);
const event = new AddEvent({
a: 1,
b: 2,
});
await eventBus.dispatch(event);
await LazyPromise.delay(TTL);
expect(result).toBeNull();
});
});
});
describe("method: listenOnce", () => {
describe("Should be null when listener added and event is not triggered", () => {
test("Object literal listener", async () => {
const listener = {
result: null,
invoke(event) {
this.result = event;
},
};
await eventBus.listenOnce(AddEvent, listener);
expect(listener.result).toBeNull();
});
test("Class instance listener", async () => {
class Listener {
result = null;
invoke(event) {
this.result = event;
}
}
const listener = new Listener();
await eventBus.listenOnce(AddEvent, listener);
expect(listener.result).toBeNull();
});
test("Function listener", async () => {
let result = null;
const listener = (event) => {
result = event;
};
await eventBus.listenOnce(AddEvent, listener);
expect(result).toBeNull();
});
});
describe("Should be AddEvent when listener added and event is triggered", () => {
test("Object literal listener", async () => {
const listener = {
result: null,
invoke(event) {
this.result = event;
},
};
await eventBus.listenOnce(AddEvent, listener);
const event = new AddEvent({
a: 1,
b: 2,
});
await eventBus.dispatch(event);
await LazyPromise.delay(TTL);
expect(listener.result).toEqual(event);
expect(listener.result).toBeInstanceOf(AddEvent);
});
test("Class instance listener", async () => {
class Listener {
result = null;
invoke(event) {
this.result = event;
}
}
const listener = new Listener();
await eventBus.listenOnce(AddEvent, listener);
const event = new AddEvent({
a: 1,
b: 2,
});
await eventBus.dispatch(event);
await LazyPromise.delay(TTL);
expect(listener.result).toEqual(event);
expect(listener.result).toBeInstanceOf(AddEvent);
});
test("Function listener", async () => {
let result = null;
const listener = (event) => {
result = event;
};
await eventBus.listenOnce(AddEvent, listener);
const event = new AddEvent({
a: 1,
b: 2,
});
await eventBus.dispatch(event);
await LazyPromise.delay(TTL);
expect(result).toEqual(event);
expect(result).toBeInstanceOf(AddEvent);
});
});
describe("Should only listen for event once", () => {
test("Object literal listener", async () => {
const listener = {
i: 0,
invoke(_event) {
this.i++;
},
};
await eventBus.listenOnce(AddEvent, listener);
const event = new AddEvent({
a: 1,
b: 2,
});
await eventBus.dispatch(event);
await eventBus.dispatch(event);
await LazyPromise.delay(TTL);
expect(listener.i).toBe(1);
});
test("Class instance listener", async () => {
class Listener {
i = 0;
invoke(_event) {
this.i++;
}
}
const listener = new Listener();
await eventBus.listenOnce(AddEvent, listener);
const event = new AddEvent({
a: 1,
b: 2,
});
await eventBus.dispatch(event);
await eventBus.dispatch(event);
await LazyPromise.delay(TTL);
expect(listener.i).toBe(1);
});
test("Function listener", async () => {
let i = 0;
const listener = () => {
i++;
};
await eventBus.listenOnce(AddEvent, listener);
const event = new AddEvent({
a: 1,
b: 2,
});
await eventBus.dispatch(event);
await eventBus.dispatch(event);
await LazyPromise.delay(TTL);
expect(i).toBe(1);
});
});
describe("Should be null when listener is removed and event is triggered", () => {
test("Object literal listener", async () => {
const listener = {
result: null,
invoke(event) {
this.result = event;
},
};
await eventBus.listenOnce(AddEvent, listener);
await eventBus.removeListener(AddEvent, listener);
const event = new AddEvent({
a: 1,
b: 2,
});
await eventBus.dispatch(event);
await LazyPromise.delay(TTL);
expect(listener.result).toBeNull();
});
test("Class instance listener", async () => {
class Listener {
result = null;
invoke(event) {
this.result = event;
}
}
const listener = new Listener();
await eventBus.listenOnce(AddEvent, listener);
await eventBus.removeListener(AddEvent, listener);
const event = new AddEvent({
a: 1,
b: 2,
});
await eventBus.dispatch(event);
await LazyPromise.delay(TTL);
expect(listener.result).toBeNull();
});
test("Function listener", async () => {
let result = null;
const listener = (event) => {
result = event;
};
await eventBus.listenOnce(AddEvent, listener);
await eventBus.removeListener(AddEvent, listener);
const event = new AddEvent({
a: 1,
b: 2,
});
await eventBus.dispatch(event);
await LazyPromise.delay(TTL);
expect(result).toBeNull();
});
});
});
describe("method: asPromise", () => {
test("Should be null when listener added and event is not triggered", () => {
let result = null;
const listener = (event) => {
result = event;
};
eventBus.asPromise(AddEvent).then(listener);
expect(result).toBeNull();
});
test("Should be AddEvent when listener added and event is triggered", async () => {
let result = null;
const listener = (event) => {
result = event;
};
eventBus.asPromise(AddEvent).then(listener);
const event = new AddEvent({
a: 1,
b: 2,
});
await eventBus.dispatch(event);
await LazyPromise.delay(TTL);
expect(result).toEqual(event);
expect(result).toBeInstanceOf(AddEvent);
});
});
}
//# sourceMappingURL=event-bus.test-suite.js.map