Add tests

packages/util/__tests__/Relay.test.ts

@@ -0,0 +1,253 @@
+import {now} from "@welshman/lib"
+import {describe, it, expect, beforeEach, vi, afterEach} from "vitest"
+import {
+  Relay,
+  normalizeRelayUrl,
+  isRelayUrl,
+  isOnionUrl,
+  isLocalUrl,
+  isIPAddress,
+  isShareableRelayUrl,
+  displayRelayUrl,
+  displayRelayProfile,
+} from "../src/Relay"
+import {Repository} from "../src/Repository"
+import type {TrustedEvent} from "../src/Events"
+
+describe("Relay", () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    vi.useFakeTimers()
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  // Realistic Nostr data
+  const pubkey = "ee".repeat(32)
+  const id = "ff".repeat(32)
+  const sig = "00".repeat(64)
+  const currentTime = now()
+  const onionUrl = "abcdefghijklmnopqrstuvwxyz234567abcdefghijklmnopqrstuvwx.onion"
+
+  const createEvent = (overrides = {}): TrustedEvent => ({
+    id: id,
+    pubkey: pubkey,
+    created_at: currentTime,
+    kind: 1,
+    tags: [],
+    content: "Hello Nostr!",
+    sig: sig,
+    ...overrides,
+  })
+
+  describe("URL utilities", () => {
+    describe("isRelayUrl", () => {
+      it("should validate proper relay URLs", () => {
+        expect(isRelayUrl("wss://relay.example.com")).toBe(true)
+        expect(isRelayUrl("ws://relay.example.com")).toBe(true)
+        expect(isRelayUrl("relay.example.com")).toBe(true)
+      })
+
+      it("should reject invalid URLs", () => {
+        expect(isRelayUrl("http://relay.example.com")).toBe(false)
+        expect(isRelayUrl("not-a-url")).toBe(false)
+        expect(isRelayUrl("ws:\\example.com\\path\\to\\file.ext")).toBe(false)
+      })
+    })
+
+    describe("isOnionUrl", () => {
+      it("should validate onion URLs", () => {
+        expect(isOnionUrl(onionUrl)).toBe(true)
+      })
+
+      it("should reject non-onion URLs", () => {
+        expect(isOnionUrl("wss://relay.example.com")).toBe(false)
+      })
+    })
+
+    describe("isLocalUrl", () => {
+      it("should validate local URLs", () => {
+        expect(isLocalUrl("wss://relay.local")).toBe(true)
+        expect(isLocalUrl("ws://localhost:8080")).toBe(true)
+      })
+
+      it("should reject non-local URLs", () => {
+        expect(isLocalUrl("wss://relay.example.com")).toBe(false)
+      })
+    })
+
+    describe("isIPAddress", () => {
+      it("should validate IP addresses", () => {
+        expect(isIPAddress("wss://192.168.1.1")).toBe(true)
+      })
+
+      it("should reject domains", () => {
+        expect(isIPAddress("wss://relay.example.com")).toBe(false)
+      })
+    })
+
+    describe("isShareableRelayUrl", () => {
+      it("should validate shareable URLs", () => {
+        expect(isShareableRelayUrl("wss://relay.example.com")).toBe(true)
+      })
+
+      it("should reject local URLs", () => {
+        expect(isShareableRelayUrl("wss://relay.local")).toBe(false)
+      })
+    })
+
+    describe("normalizeRelayUrl", () => {
+      it("should normalize URLs consistently", () => {
+        expect(normalizeRelayUrl("relay.example.com")).toBe("wss://relay.example.com/")
+        expect(normalizeRelayUrl("wss://RELAY.EXAMPLE.COM")).toBe("wss://relay.example.com/")
+      })
+
+      it("should handle onion URLs", () => {
+        expect(normalizeRelayUrl(onionUrl)).toBe(`ws://${onionUrl}/`)
+      })
+    })
+
+    describe("displayRelayUrl", () => {
+      it("should format URLs for display", () => {
+        expect(displayRelayUrl("wss://relay.example.com/")).toBe("relay.example.com")
+      })
+    })
+
+    describe("displayRelayProfile", () => {
+      it("should display profile name when available", () => {
+        const profile = {url: "wss://relay.example.com", name: "Test Relay"}
+        expect(displayRelayProfile(profile)).toBe("Test Relay")
+      })
+
+      it("should use fallback when no name", () => {
+        const profile = {url: "wss://relay.example.com"}
+        expect(displayRelayProfile(profile, "Fallback")).toBe("Fallback")
+      })
+    })
+  })
+
+  describe("Relay class", () => {
+    let relay: Relay
+    let repository: Repository<TrustedEvent>
+
+    beforeEach(() => {
+      repository = new Repository<TrustedEvent>()
+      relay = new Relay(repository)
+    })
+
+    describe("EVENT handling", () => {
+      it("should publish events to repository", async () => {
+        const event = createEvent()
+        const publishSpy = vi.spyOn(repository, "publish")
+
+        relay.send("EVENT", event)
+
+        expect(publishSpy).toHaveBeenCalledWith(event)
+
+        // Should emit OK
+        const okHandler = vi.fn()
+        relay.on("OK", okHandler)
+
+        // Wait for async operations
+        await vi.runAllTimersAsync()
+
+        expect(okHandler).toHaveBeenCalledWith(event.id, true, "")
+      })
+
+      it("should notify matching subscribers", async () => {
+        const event = createEvent()
+        const subId = "test-sub"
+        const filter = {kinds: [1]}
+
+        relay.send("REQ", subId, filter)
+
+        const eventHandler = vi.fn()
+        relay.on("EVENT", eventHandler)
+
+        relay.send("EVENT", event)
+
+        await vi.runAllTimersAsync()
+
+        expect(eventHandler).toHaveBeenCalledWith(subId, event)
+      })
+
+      it("should not notify for deleted events", async () => {
+        const event = createEvent()
+        repository.removeEvent(event.id)
+
+        const eventHandler = vi.fn()
+        relay.on("EVENT", eventHandler)
+
+        relay.send("EVENT", event)
+
+        await vi.runAllTimersAsync()
+
+        expect(eventHandler).not.toHaveBeenCalled()
+      })
+    })
+
+    describe("REQ handling", () => {
+      it("should handle subscription requests", async () => {
+        const event = createEvent()
+        repository.publish(event)
+
+        const subId = "test-sub"
+        const filter = {kinds: [1]}
+
+        const eventHandler = vi.fn()
+        const eoseHandler = vi.fn()
+
+        relay.on("EVENT", eventHandler)
+        relay.on("EOSE", eoseHandler)
+
+        relay.send("REQ", subId, filter)
+
+        await vi.runAllTimersAsync()
+
+        expect(eventHandler).toHaveBeenCalledWith(subId, event)
+        expect(eoseHandler).toHaveBeenCalledWith(subId)
+      })
+
+      it("should handle multiple filters", async () => {
+        const event1 = createEvent({kind: 1})
+        const event2 = createEvent({kind: 2, id: "ee".repeat(31)})
+        repository.publish(event1)
+        repository.publish(event2)
+
+        const subId = "test-sub"
+        const filters = [{kinds: [1]}, {kinds: [2]}]
+
+        const eventHandler = vi.fn()
+        relay.on("EVENT", eventHandler)
+
+        relay.send("REQ", subId, ...filters)
+
+        await vi.runAllTimersAsync()
+
+        expect(eventHandler).toHaveBeenCalledTimes(2)
+      })
+    })
+
+    describe("CLOSE handling", () => {
+      it("should close subscriptions", async () => {
+        const subId = "test-sub"
+        relay.send("REQ", subId, {kinds: [1]})
+        relay.send("CLOSE", subId)
+
+        await vi.runAllTimersAsync()
+
+        const event = createEvent()
+        const eventHandler = vi.fn()
+        relay.on("EVENT", eventHandler)
+
+        relay.send("EVENT", event)
+
+        await vi.runAllTimersAsync()
+
+        expect(eventHandler).not.toHaveBeenCalled()
+      })
+    })
+  })
+})