@bsb/events-rabbitmq 0.0.1

package/lib/tests/plugins/events/events/broadcast.js

@@ -0,0 +1,320 @@
+import * as assert from "assert";
+import { randomUUID } from "crypto";
+import { SmartFunctionCallSync } from "@bsb/base";
+import { createTestObservable } from "../../../trace.js";
+const randomName = () => randomUUID();
+export function broadcast(genNewPlugin, maxTimeoutToExpectAResponse) {
+    let emitter;
+    beforeEach(async () => {
+        emitter = await genNewPlugin();
+    });
+    afterEach(function () {
+        SmartFunctionCallSync(emitter, emitter.dispose);
+    });
+    describe("EmitBroadcast", async function () {
+        this.timeout(maxTimeoutToExpectAResponse + 100);
+        describe("emitBroadcast", async () => {
+            const emitData = true;
+            it("all plugins should receive the event", async () => {
+                const thisPlugin = randomName();
+                const thisEvent = randomName();
+                const obs = createTestObservable();
+                let receiveCounter = 0;
+                setTimeout(() => {
+                    if (receiveCounter === 2) {
+                        return assert.ok(receiveCounter);
+                    }
+                    if (receiveCounter === 0) {
+                        return assert.fail("Event not received");
+                    }
+                    assert.fail("Received " + receiveCounter + " events");
+                }, maxTimeoutToExpectAResponse);
+                await emitter.onBroadcast(obs, thisPlugin, thisEvent, async (receivedObs, args) => {
+                    assert.strictEqual(receivedObs.traceId, obs.traceId);
+                    receiveCounter++;
+                });
+                await emitter.onBroadcast(obs, thisPlugin, thisEvent, async (receivedObs, args) => {
+                    assert.strictEqual(receivedObs.traceId, obs.traceId);
+                    receiveCounter++;
+                });
+                await emitter.emitBroadcast(obs, thisPlugin, thisEvent, [emitData]);
+                await new Promise(resolve => setTimeout(resolve, 10));
+            });
+            it("diff plugin names should not receive same event", async () => {
+                const thisPlugin = randomName();
+                const thisPlugin2 = randomName();
+                const thisEvent = randomName();
+                const obs = createTestObservable();
+                let receiveCounter = 0;
+                setTimeout(() => {
+                    if (receiveCounter === 2) {
+                        return assert.ok(receiveCounter);
+                    }
+                    if (receiveCounter === 0) {
+                        return assert.fail("Event not received");
+                    }
+                    assert.fail("Received " + receiveCounter + " events");
+                }, maxTimeoutToExpectAResponse);
+                await emitter.onBroadcast(obs, thisPlugin, thisEvent, async () => {
+                    assert.fail("Received on diff plugin name");
+                });
+                await emitter.onBroadcast(obs, thisPlugin2, thisEvent, async (receivedObs, args) => {
+                    assert.strictEqual(receivedObs.traceId, obs.traceId);
+                    receiveCounter++;
+                });
+                await emitter.onBroadcast(obs, thisPlugin2, thisEvent, async (receivedObs, args) => {
+                    assert.strictEqual(receivedObs.traceId, obs.traceId);
+                    receiveCounter++;
+                });
+                await emitter.emitBroadcast(obs, thisPlugin2, thisEvent, [emitData]);
+                await new Promise(resolve => setTimeout(resolve, 10));
+            });
+            it("should be able to emit to events with plugin name defined", async () => {
+                const thisPlugin = randomName();
+                const thisEvent = randomName();
+                const obs = createTestObservable();
+                const emitTimeout = setTimeout(() => {
+                    assert.fail("Event not received");
+                }, maxTimeoutToExpectAResponse);
+                await emitter.onBroadcast(obs, thisPlugin, thisEvent, async (receivedObs, data) => {
+                    clearTimeout(emitTimeout);
+                    assert.strictEqual(receivedObs.traceId, obs.traceId);
+                    assert.ok(data[0]);
+                });
+                await emitter.emitBroadcast(obs, thisPlugin, thisEvent, [emitData]);
+                await new Promise(resolve => setTimeout(resolve, 10));
+            });
+            it("should be able to emit to events with self", async () => {
+                const thisCaller = randomName();
+                const thisEvent = randomName();
+                const obs = createTestObservable();
+                const emitTimeout = setTimeout(() => {
+                    assert.fail("Event not received");
+                }, maxTimeoutToExpectAResponse);
+                await emitter.onBroadcast(obs, thisCaller, thisEvent, async (receivedObs, data) => {
+                    clearTimeout(emitTimeout);
+                    assert.strictEqual(receivedObs.traceId, obs.traceId);
+                    assert.ok(data[0]);
+                });
+                await emitter.emitBroadcast(obs, thisCaller, thisEvent, [emitData]);
+                await new Promise(resolve => setTimeout(resolve, 10));
+            });
+            it("should be able to emit to events with self multi-args", async () => {
+                const thisCaller = randomName();
+                const thisEvent = randomName();
+                const obs = createTestObservable();
+                const emitTimeout = setTimeout(() => {
+                    assert.fail("Event not received");
+                }, maxTimeoutToExpectAResponse);
+                await emitter.onBroadcast(obs, thisCaller, thisEvent, async (receivedObs, data) => {
+                    clearTimeout(emitTimeout);
+                    assert.strictEqual(receivedObs.traceId, obs.traceId);
+                    assert.deepEqual(data[0], 0);
+                    assert.deepEqual(data[1], 1);
+                    assert.deepEqual(data[2], 2);
+                    assert.deepEqual(data[3], 3);
+                });
+                await emitter.emitBroadcast(obs, thisCaller, thisEvent, [0, 1, 2, 3]);
+                await new Promise(resolve => setTimeout(resolve, 10));
+            });
+            it("should not be able to emit to other events with plugin name defined", async () => {
+                const thisPlugin = randomName();
+                const thisEvent = randomName();
+                const thisEvent2 = randomName();
+                const obs = createTestObservable();
+                const emitTimeout = setTimeout(() => {
+                    assert.ok(true);
+                }, maxTimeoutToExpectAResponse);
+                await emitter.onBroadcast(obs, thisPlugin, thisEvent, async () => {
+                    clearTimeout(emitTimeout);
+                    assert.fail("Event received");
+                });
+                await emitter.emitBroadcast(obs, thisPlugin, thisEvent2, [emitData]);
+                await new Promise(resolve => setTimeout(resolve, 10));
+            });
+            it("should not be able to emit to other events with self", async () => {
+                const thisCaller = randomName();
+                const thisEvent = randomName();
+                const thisEvent2 = randomName();
+                const obs = createTestObservable();
+                const emitTimeout = setTimeout(() => {
+                    assert.ok(true);
+                }, maxTimeoutToExpectAResponse);
+                await emitter.onBroadcast(obs, thisCaller, thisEvent, async () => {
+                    clearTimeout(emitTimeout);
+                    assert.fail("Event received");
+                });
+                await emitter.emitBroadcast(obs, thisCaller, thisEvent2, [emitData]);
+                await new Promise(resolve => setTimeout(resolve, 10));
+            });
+        });
+        describe("onBroadcast", async () => {
+            const emitData = "ABCD";
+            it("should be able to emit to events with plugin name defined", async () => {
+                const thisPlugin = randomName();
+                const thisEvent = randomName();
+                const obs = createTestObservable();
+                const emitTimeout = setTimeout(() => {
+                    assert.fail("Event not received");
+                }, maxTimeoutToExpectAResponse);
+                await emitter.onBroadcast(obs, thisPlugin, thisEvent, async (receivedObs, data) => {
+                    clearTimeout(emitTimeout);
+                    assert.strictEqual(receivedObs.traceId, obs.traceId);
+                    assert.deepEqual(data[0], emitData);
+                });
+                await emitter.emitBroadcast(obs, thisPlugin, thisEvent, [emitData]);
+                await new Promise(resolve => setTimeout(resolve, 10));
+            });
+            it("should be able to emit to events with self", async () => {
+                const thisCaller = randomName();
+                const thisEvent = randomName();
+                const obs = createTestObservable();
+                const emitTimeout = setTimeout(() => {
+                    assert.fail("Event not received");
+                }, maxTimeoutToExpectAResponse);
+                await emitter.onBroadcast(obs, thisCaller, thisEvent, async (receivedObs, data) => {
+                    clearTimeout(emitTimeout);
+                    assert.strictEqual(receivedObs.traceId, obs.traceId);
+                    assert.deepEqual(data[0], emitData);
+                });
+                await emitter.emitBroadcast(obs, thisCaller, thisEvent, [emitData]);
+                await new Promise(resolve => setTimeout(resolve, 10));
+            });
+            it("should not be able to emit to other events with plugin name defined", async () => {
+                const thisPlugin = randomName();
+                const thisEvent = randomName();
+                const thisEvent2 = randomName();
+                const obs = createTestObservable();
+                const emitTimeout = setTimeout(() => {
+                    assert.ok(true);
+                }, maxTimeoutToExpectAResponse);
+                await emitter.onBroadcast(obs, thisPlugin, thisEvent, async () => {
+                    clearTimeout(emitTimeout);
+                    assert.fail("Event received");
+                });
+                await emitter.emitBroadcast(obs, thisPlugin, thisEvent2, [emitData]);
+                await new Promise(resolve => setTimeout(resolve, 10));
+            });
+            it("should not be able to emit to other events with self", async () => {
+                const thisCaller = randomName();
+                const thisEvent = randomName();
+                const thisEvent2 = randomName();
+                const obs = createTestObservable();
+                const emitTimeout = setTimeout(() => {
+                    assert.ok(true);
+                }, maxTimeoutToExpectAResponse);
+                await emitter.onBroadcast(obs, thisCaller, thisEvent, async () => {
+                    clearTimeout(emitTimeout);
+                    assert.fail("Event received");
+                });
+                await emitter.emitBroadcast(obs, thisCaller, thisEvent2, [emitData]);
+                await new Promise(resolve => setTimeout(resolve, 10));
+            });
+        });
+        const typesToTest = [
+            {
+                name: "Null",
+                data: null,
+            },
+            {
+                name: "Boolean true",
+                data: true,
+            },
+            {
+                name: "Boolean false",
+                data: false,
+            },
+            {
+                name: "String",
+                data: "HELLO WO4lD",
+            },
+            {
+                name: "Min Number",
+                data: Number.MIN_SAFE_INTEGER,
+            },
+            {
+                name: "Max Number",
+                data: Number.MAX_SAFE_INTEGER,
+            },
+            {
+                name: "Array",
+                data: [0, "Hello", true],
+            },
+            {
+                name: "Object",
+                data: {
+                    name: "Sarah",
+                    surname: "Blond",
+                    age: 24,
+                    meta: {
+                        location: [-12212, 55336],
+                    },
+                },
+            },
+        ];
+        for (const typeToTest of typesToTest) {
+            describe(`emitBroadcast ${typeToTest.name}`, async () => {
+                it("should be able to emit to events with plugin name defined", async () => {
+                    const thisPlugin = randomName();
+                    const thisEvent = randomName();
+                    const obs = createTestObservable();
+                    const emitTimeout = setTimeout(() => {
+                        assert.fail("Event not received");
+                    }, maxTimeoutToExpectAResponse);
+                    await emitter.onBroadcast(obs, thisPlugin, thisEvent, async (receivedObs, data) => {
+                        clearTimeout(emitTimeout);
+                        assert.strictEqual(receivedObs.traceId, obs.traceId);
+                        assert.deepEqual(data[0], typeToTest.data);
+                    });
+                    await emitter.emitBroadcast(obs, thisPlugin, thisEvent, [typeToTest.data]);
+                    await new Promise(resolve => setTimeout(resolve, 10));
+                });
+                it("should be able to emit to events with self", async () => {
+                    const thisCaller = randomName();
+                    const thisEvent = randomName();
+                    const obs = createTestObservable();
+                    const emitTimeout = setTimeout(() => {
+                        assert.fail("Event not received");
+                    }, maxTimeoutToExpectAResponse);
+                    await emitter.onBroadcast(obs, thisCaller, thisEvent, async (receivedObs, data) => {
+                        clearTimeout(emitTimeout);
+                        assert.strictEqual(receivedObs.traceId, obs.traceId);
+                        assert.deepEqual(data[0], typeToTest.data);
+                    });
+                    await emitter.emitBroadcast(obs, thisCaller, thisEvent, [typeToTest.data]);
+                    await new Promise(resolve => setTimeout(resolve, 10));
+                });
+                it("should not be able to emit to other events with plugin name defined", async () => {
+                    const thisPlugin = randomName();
+                    const thisEvent = randomName();
+                    const thisEvent2 = randomName();
+                    const obs = createTestObservable();
+                    const emitTimeout = setTimeout(() => {
+                        assert.ok(true);
+                    }, maxTimeoutToExpectAResponse);
+                    await emitter.onBroadcast(obs, thisPlugin, thisEvent, async () => {
+                        clearTimeout(emitTimeout);
+                        assert.fail("Event received");
+                    });
+                    await emitter.emitBroadcast(obs, thisPlugin, thisEvent2, [typeToTest.data]);
+                    await new Promise(resolve => setTimeout(resolve, 10));
+                });
+                it("should not be able to emit to other events with self", async () => {
+                    const thisCaller = randomName();
+                    const thisEvent = randomName();
+                    const thisEvent2 = randomName();
+                    const obs = createTestObservable();
+                    const emitTimeout = setTimeout(() => {
+                        assert.ok(true);
+                    }, maxTimeoutToExpectAResponse);
+                    await emitter.onBroadcast(obs, thisCaller, thisEvent, async () => {
+                        clearTimeout(emitTimeout);
+                        assert.fail("Event received");
+                    });
+                    await emitter.emitBroadcast(obs, thisCaller, thisEvent2, [typeToTest.data]);
+                    await new Promise(resolve => setTimeout(resolve, 10));
+                });
+            });
+        }
+    });
+}

package/lib/tests/plugins/events/events/emit.d.ts

@@ -0,0 +1,4 @@
+import { BSBEvents } from "@bsb/base";
+export declare function emit(genNewPlugin: {
+    (): Promise<BSBEvents>;
+}, maxTimeoutToExpectAResponse: number): void;

package/lib/tests/plugins/events/events/emit.js

@@ -0,0 +1,316 @@
+import * as assert from "assert";
+import { randomUUID } from "crypto";
+import { SmartFunctionCallSync } from "@bsb/base";
+import { createTestObservable } from "../../../trace.js";
+const randomName = () => randomUUID();
+export function emit(genNewPlugin, maxTimeoutToExpectAResponse) {
+    let emitter;
+    beforeEach(async () => {
+        emitter = await genNewPlugin();
+    });
+    afterEach(function () {
+        SmartFunctionCallSync(emitter, emitter.dispose);
+    });
+    describe("Emit", async function () {
+        this.timeout(maxTimeoutToExpectAResponse + 100);
+        describe("emitEvent", async () => {
+            const emitData = true;
+            it("only one plugin should receive the event", async () => {
+                const thisPlugin = randomName();
+                const thisEvent = randomName();
+                const obs = createTestObservable();
+                let receiveCounter = 0;
+                await emitter.onEvent(obs, thisPlugin, thisEvent, async (receivedObs, args) => {
+                    assert.strictEqual(receivedObs.traceId, obs.traceId);
+                    receiveCounter++;
+                });
+                await emitter.onEvent(obs, thisPlugin, thisEvent, async (receivedObs, args) => {
+                    assert.strictEqual(receivedObs.traceId, obs.traceId);
+                    receiveCounter++;
+                });
+                await emitter.emitEvent(obs, thisPlugin, thisEvent, [emitData]);
+                await new Promise(resolve => setTimeout(resolve, 10));
+                if (receiveCounter === 1) {
+                    return assert.ok(receiveCounter);
+                }
+                if (receiveCounter === 0) {
+                    return assert.fail("Event not received");
+                }
+                assert.fail("Received " + receiveCounter + " events");
+            });
+            it("diff plugin names should not receive same event", async () => {
+                const thisPlugin = randomName();
+                const thisPlugin2 = randomName();
+                const thisEvent = randomName();
+                const obs = createTestObservable();
+                let receiveCounter = 0;
+                await emitter.onEvent(obs, thisPlugin, thisEvent, async () => {
+                    assert.fail("Received on diff plugin name");
+                });
+                await emitter.onEvent(obs, thisPlugin2, thisEvent, async (receivedObs, args) => {
+                    assert.strictEqual(receivedObs.traceId, obs.traceId);
+                    receiveCounter++;
+                });
+                await emitter.onEvent(obs, thisPlugin2, thisEvent, async (receivedObs, args) => {
+                    assert.strictEqual(receivedObs.traceId, obs.traceId);
+                    receiveCounter++;
+                });
+                await emitter.emitEvent(obs, thisPlugin2, thisEvent, [emitData]);
+                await new Promise(resolve => setTimeout(resolve, 10));
+                if (receiveCounter === 1) {
+                    return assert.ok(receiveCounter);
+                }
+                if (receiveCounter === 0) {
+                    return assert.fail("Event not received");
+                }
+                assert.fail("Received " + receiveCounter + " events");
+            });
+            it("should be able to emit to events with plugin name defined", async () => {
+                const thisPlugin = randomName();
+                const thisEvent = randomName();
+                const obs = createTestObservable();
+                const emitTimeout = setTimeout(() => {
+                    assert.fail("Event not received");
+                }, maxTimeoutToExpectAResponse);
+                await emitter.onEvent(obs, thisPlugin, thisEvent, async (receivedObs, data) => {
+                    clearTimeout(emitTimeout);
+                    assert.strictEqual(receivedObs.traceId, obs.traceId);
+                    assert.ok(data[0]);
+                });
+                await emitter.emitEvent(obs, thisPlugin, thisEvent, [emitData]);
+                await new Promise(resolve => setTimeout(resolve, 10));
+            });
+            it("should be able to emit to events with self", async () => {
+                const thisCaller = randomName();
+                const thisEvent = randomName();
+                const obs = createTestObservable();
+                const emitTimeout = setTimeout(() => {
+                    assert.fail("Event not received");
+                }, maxTimeoutToExpectAResponse);
+                await emitter.onEvent(obs, thisCaller, thisEvent, async (receivedObs, data) => {
+                    clearTimeout(emitTimeout);
+                    assert.strictEqual(receivedObs.traceId, obs.traceId);
+                    assert.ok(data[0]);
+                });
+                await emitter.emitEvent(obs, thisCaller, thisEvent, [emitData]);
+                await new Promise(resolve => setTimeout(resolve, 10));
+            });
+            it("should be able to emit to events with self multi-args", async () => {
+                const thisCaller = randomName();
+                const thisEvent = randomName();
+                const obs = createTestObservable();
+                const emitTimeout = setTimeout(() => {
+                    assert.fail("Event not received");
+                }, maxTimeoutToExpectAResponse);
+                await emitter.onEvent(obs, thisCaller, thisEvent, async (receivedObs, data) => {
+                    clearTimeout(emitTimeout);
+                    assert.strictEqual(receivedObs.traceId, obs.traceId);
+                    assert.deepEqual(data[0], 0);
+                    assert.deepEqual(data[1], 1);
+                    assert.deepEqual(data[2], 2);
+                    assert.deepEqual(data[3], 3);
+                });
+                await emitter.emitEvent(obs, thisCaller, thisEvent, [0, 1, 2, 3]);
+                await new Promise(resolve => setTimeout(resolve, 10));
+            });
+            it("should not be able to emit to other events with plugin name defined", async () => {
+                const thisPlugin = randomName();
+                const thisEvent = randomName();
+                const thisEvent2 = randomName();
+                const obs = createTestObservable();
+                const emitTimeout = setTimeout(() => {
+                    assert.ok(true);
+                }, maxTimeoutToExpectAResponse);
+                await emitter.onEvent(obs, thisPlugin, thisEvent, async () => {
+                    clearTimeout(emitTimeout);
+                    assert.fail("Event received");
+                });
+                await emitter.emitEvent(obs, thisPlugin, thisEvent2, [emitData]);
+                await new Promise(resolve => setTimeout(resolve, 10));
+            });
+            it("should not be able to emit to other events with self", async () => {
+                const thisCaller = randomName();
+                const thisEvent = randomName();
+                const thisEvent2 = randomName();
+                const obs = createTestObservable();
+                const emitTimeout = setTimeout(() => {
+                    assert.ok(true);
+                }, maxTimeoutToExpectAResponse);
+                await emitter.onEvent(obs, thisCaller, thisEvent, async () => {
+                    clearTimeout(emitTimeout);
+                    assert.fail("Event received");
+                });
+                await emitter.emitEvent(obs, thisCaller, thisEvent2, [emitData]);
+                await new Promise(resolve => setTimeout(resolve, 10));
+            });
+        });
+        describe("onEvent", async () => {
+            const emitData = "ABCD";
+            it("should be able to emit to events with plugin name defined", async () => {
+                const thisPlugin = randomName();
+                const thisEvent = randomName();
+                const obs = createTestObservable();
+                const emitTimeout = setTimeout(() => {
+                    assert.fail("Event not received");
+                }, maxTimeoutToExpectAResponse);
+                await emitter.onEvent(obs, thisPlugin, thisEvent, async (receivedObs, data) => {
+                    clearTimeout(emitTimeout);
+                    assert.strictEqual(receivedObs.traceId, obs.traceId);
+                    assert.deepEqual(data[0], emitData);
+                });
+                await emitter.emitEvent(obs, thisPlugin, thisEvent, [emitData]);
+                await new Promise(resolve => setTimeout(resolve, 10));
+            });
+            it("should be able to emit to events with self", async () => {
+                const thisCaller = randomName();
+                const thisEvent = randomName();
+                const obs = createTestObservable();
+                const emitTimeout = setTimeout(() => {
+                    assert.fail("Event not received");
+                }, maxTimeoutToExpectAResponse);
+                await emitter.onEvent(obs, thisCaller, thisEvent, async (receivedObs, data) => {
+                    clearTimeout(emitTimeout);
+                    assert.strictEqual(receivedObs.traceId, obs.traceId);
+                    assert.deepEqual(data[0], emitData);
+                });
+                await emitter.emitEvent(obs, thisCaller, thisEvent, [emitData]);
+                await new Promise(resolve => setTimeout(resolve, 10));
+            });
+            it("should not be able to emit to other events with plugin name defined", async () => {
+                const thisPlugin = randomName();
+                const thisEvent = randomName();
+                const thisEvent2 = randomName();
+                const obs = createTestObservable();
+                const emitTimeout = setTimeout(() => {
+                    assert.ok(true);
+                }, maxTimeoutToExpectAResponse);
+                await emitter.onEvent(obs, thisPlugin, thisEvent, async () => {
+                    clearTimeout(emitTimeout);
+                    assert.fail("Event received");
+                });
+                await emitter.emitEvent(obs, thisPlugin, thisEvent2, [emitData]);
+                await new Promise(resolve => setTimeout(resolve, 10));
+            });
+            it("should not be able to emit to other events with self", async () => {
+                const thisCaller = randomName();
+                const thisEvent = randomName();
+                const thisEvent2 = randomName();
+                const obs = createTestObservable();
+                const emitTimeout = setTimeout(() => {
+                    assert.ok(true);
+                }, maxTimeoutToExpectAResponse);
+                await emitter.onEvent(obs, thisCaller, thisEvent, async () => {
+                    clearTimeout(emitTimeout);
+                    assert.fail("Event received");
+                });
+                await emitter.emitEvent(obs, thisCaller, thisEvent2, [emitData]);
+                await new Promise(resolve => setTimeout(resolve, 10));
+            });
+        });
+        const typesToTest = [
+            {
+                name: "Null",
+                data: null,
+            },
+            {
+                name: "Boolean true",
+                data: true,
+            },
+            {
+                name: "Boolean false",
+                data: false,
+            },
+            {
+                name: "String",
+                data: "HELLO WO4lD",
+            },
+            {
+                name: "Min Number",
+                data: Number.MIN_SAFE_INTEGER,
+            },
+            {
+                name: "Max Number",
+                data: Number.MAX_SAFE_INTEGER,
+            },
+            {
+                name: "Array",
+                data: [0, "Hello", true],
+            },
+            {
+                name: "Object",
+                data: {
+                    name: "Sarah",
+                    surname: "Blond",
+                    age: 24,
+                    meta: {
+                        location: [-12212, 55336],
+                    },
+                },
+            },
+        ];
+        for (const typeToTest of typesToTest) {
+            describe(`emitEvent ${typeToTest.name}`, async () => {
+                it("should be able to emit to events with plugin name defined", async () => {
+                    const thisPlugin = randomName();
+                    const thisEvent = randomName();
+                    const obs = createTestObservable();
+                    const emitTimeout = setTimeout(() => {
+                        assert.fail("Event not received");
+                    }, maxTimeoutToExpectAResponse);
+                    await emitter.onEvent(obs, thisPlugin, thisEvent, async (receivedObs, data) => {
+                        clearTimeout(emitTimeout);
+                        assert.strictEqual(receivedObs.traceId, obs.traceId);
+                        assert.deepEqual(data[0], typeToTest.data);
+                    });
+                    await emitter.emitEvent(obs, thisPlugin, thisEvent, [typeToTest.data]);
+                    await new Promise(resolve => setTimeout(resolve, 10));
+                });
+                it("should be able to emit to events with self", async () => {
+                    const thisCaller = randomName();
+                    const thisEvent = randomName();
+                    const obs = createTestObservable();
+                    const emitTimeout = setTimeout(() => {
+                        assert.fail("Event not received");
+                    }, maxTimeoutToExpectAResponse);
+                    await emitter.onEvent(obs, thisCaller, thisEvent, async (receivedObs, data) => {
+                        clearTimeout(emitTimeout);
+                        assert.strictEqual(receivedObs.traceId, obs.traceId);
+                        assert.deepEqual(data[0], typeToTest.data);
+                    });
+                    await emitter.emitEvent(obs, thisCaller, thisEvent, [typeToTest.data]);
+                    await new Promise(resolve => setTimeout(resolve, 10));
+                });
+                it("should not be able to emit to other events with plugin name defined", async () => {
+                    const thisPlugin = randomName();
+                    const thisEvent = randomName();
+                    const thisEvent2 = randomName();
+                    const obs = createTestObservable();
+                    const emitTimeout = setTimeout(() => {
+                        assert.ok(true);
+                    }, maxTimeoutToExpectAResponse);
+                    await emitter.onEvent(obs, thisPlugin, thisEvent, async () => {
+                        clearTimeout(emitTimeout);
+                        assert.fail("Event received");
+                    });
+                    await emitter.emitEvent(obs, thisPlugin, thisEvent2, [typeToTest.data]);
+                    await new Promise(resolve => setTimeout(resolve, 10));
+                });
+                it("should not be able to emit to other events with self", async () => {
+                    const thisCaller = randomName();
+                    const thisEvent = randomName();
+                    const thisEvent2 = randomName();
+                    const obs = createTestObservable();
+                    const emitTimeout = setTimeout(() => {
+                        assert.ok(true);
+                    }, maxTimeoutToExpectAResponse);
+                    await emitter.onEvent(obs, thisCaller, thisEvent, async () => {
+                        clearTimeout(emitTimeout);
+                        assert.fail("Event received");
+                    });
+                    await emitter.emitEvent(obs, thisCaller, thisEvent2, [typeToTest.data]);
+                    await new Promise(resolve => setTimeout(resolve, 10));
+                });
+            });
+        }
+    });
+}

package/lib/tests/plugins/events/events/emitAndReturn.d.ts

@@ -0,0 +1,4 @@
+import { BSBEvents } from "@bsb/base";
+export declare function emitAndReturn(genNewPlugin: {
+    (): Promise<BSBEvents>;
+}, maxTimeoutToExpectAResponse: number): void;