Add tests

packages/lib/__tests__/Emitter.test.ts

@@ -0,0 +1,160 @@
+import {describe, it, expect, beforeEach, vi} from "vitest"
+import {Emitter} from "../src/Emitter"
+
+describe("Emitter", () => {
+  let emitter: Emitter
+
+  beforeEach(() => {
+    emitter = new Emitter()
+  })
+
+  it("should emit events to specific listeners", () => {
+    const listener = vi.fn()
+    emitter.on("test", listener)
+
+    const args = ["arg1", 2, {key: "value"}]
+    emitter.emit("test", ...args)
+
+    expect(listener).toHaveBeenCalledWith(...args)
+    expect(listener).toHaveBeenCalledTimes(1)
+  })
+
+  it("should emit events to wildcard listeners", () => {
+    const wildcardListener = vi.fn()
+    emitter.on("*", wildcardListener)
+
+    const args = ["arg1", 2, {key: "value"}]
+    emitter.emit("test", ...args)
+
+    expect(wildcardListener).toHaveBeenCalledWith("test", ...args)
+    expect(wildcardListener).toHaveBeenCalledTimes(1)
+  })
+
+  it("should emit to both specific and wildcard listeners", () => {
+    const specificListener = vi.fn()
+    const wildcardListener = vi.fn()
+
+    emitter.on("test", specificListener)
+    emitter.on("*", wildcardListener)
+
+    const args = ["arg1", 2, {key: "value"}]
+    emitter.emit("test", ...args)
+
+    expect(specificListener).toHaveBeenCalledWith(...args)
+    expect(wildcardListener).toHaveBeenCalledWith("test", ...args)
+  })
+
+  it("should return true if both listeners exist", () => {
+    emitter.on("test", () => {})
+    emitter.on("*", () => {})
+
+    const result = emitter.emit("test", "arg")
+    expect(result).toBe(true)
+  })
+
+  it("should return false if no listeners exist", () => {
+    const result = emitter.emit("test", "arg")
+    expect(result).toBe(false)
+  })
+
+  it("should handle multiple listeners for same event", () => {
+    const listener1 = vi.fn()
+    const listener2 = vi.fn()
+
+    emitter.on("test", listener1)
+    emitter.on("test", listener2)
+
+    emitter.emit("test", "arg")
+
+    expect(listener1).toHaveBeenCalledWith("arg")
+    expect(listener2).toHaveBeenCalledWith("arg")
+  })
+
+  it("should handle multiple wildcard listeners", () => {
+    const listener1 = vi.fn()
+    const listener2 = vi.fn()
+
+    emitter.on("*", listener1)
+    emitter.on("*", listener2)
+
+    emitter.emit("test", "arg")
+
+    expect(listener1).toHaveBeenCalledWith("test", "arg")
+    expect(listener2).toHaveBeenCalledWith("test", "arg")
+  })
+
+  it("should handle listener removal", () => {
+    const listener = vi.fn()
+    emitter.on("test", listener)
+    emitter.removeListener("test", listener)
+
+    emitter.emit("test", "arg")
+
+    expect(listener).not.toHaveBeenCalled()
+  })
+
+  it("should handle wildcard listener removal", () => {
+    const listener = vi.fn()
+    emitter.on("*", listener)
+    emitter.removeListener("*", listener)
+
+    emitter.emit("test", "arg")
+
+    expect(listener).not.toHaveBeenCalled()
+  })
+
+  it("should handle once listeners", () => {
+    const listener = vi.fn()
+    emitter.once("test", listener)
+
+    emitter.emit("test", "arg1")
+    emitter.emit("test", "arg2")
+
+    expect(listener).toHaveBeenCalledTimes(1)
+    expect(listener).toHaveBeenCalledWith("arg1")
+  })
+
+  it("should handle once wildcard listeners", () => {
+    const listener = vi.fn()
+    emitter.once("*", listener)
+
+    emitter.emit("test1", "arg1")
+    emitter.emit("test2", "arg2")
+
+    expect(listener).toHaveBeenCalledTimes(1)
+    expect(listener).toHaveBeenCalledWith("test1", "arg1")
+  })
+
+  it("should handle nostr event data", () => {
+    const listener = vi.fn()
+    const wildcardListener = vi.fn()
+
+    emitter.on("test", listener)
+    emitter.on("*", wildcardListener)
+
+    const complexData = {
+      id: "ff".repeat(32), // Realistic event ID
+      pubkey: "ee".repeat(32), // Realistic pubkey
+      created_at: Math.floor(Date.now() / 1000),
+      kind: 1,
+      tags: [["p", "ee".repeat(32)]],
+      content: "Hello Nostr!",
+    }
+
+    emitter.emit("test", complexData)
+
+    expect(listener).toHaveBeenCalledWith(complexData)
+    expect(wildcardListener).toHaveBeenCalledWith("test", complexData)
+  })
+
+  it("should maintain correct event order", () => {
+    const events: string[] = []
+
+    emitter.on("test", () => events.push("specific"))
+    emitter.on("*", () => events.push("wildcard"))
+
+    emitter.emit("test")
+
+    expect(events).toEqual(["specific", "wildcard"])
+  })
+})