psf-bch-api 1.1.0 → 1.3.0

package/test/integration/use-cases/manage-subscription-integration.js

@@ -1,163 +0,0 @@
-/*
-  Integration tests for ManageSubscriptionUseCase with real adapter.
-  These tests require a running Nostr relay.
-*/
-
-// npm libraries
-import { assert } from 'chai'
-
-// Unit under test
-import Adapters from '../../../src/adapters/index.js'
-import ManageSubscriptionUseCase from '../../../src/use-cases/manage-subscription.js'
-
-describe('#manage-subscription-integration.js', () => {
-  let adapters
-  let uut
-
-  before(async () => {
-    // Initialize adapters (will connect to real relay)
-    adapters = new Adapters()
-    await adapters.start()
-
-    uut = new ManageSubscriptionUseCase({ adapters })
-  })
-
-  after(async () => {
-    // Clean up all subscriptions and disconnect from all relays
-    // Note: This is a simplified cleanup - in production you'd track all subscriptions
-    if (adapters && adapters.nostrRelays) {
-      await Promise.allSettled(
-        adapters.nostrRelays.map(relay => relay.disconnect())
-      )
-    }
-  })
-
-  describe('#createSubscription()', () => {
-    it('should successfully create a subscription', async () => {
-      const subscriptionId = 'test-sub-' + Date.now()
-      const filters = [{ kinds: [1], limit: 5 }]
-
-      let eventReceived = false
-      let eoseReceived = false
-
-      const onEvent = (event) => {
-        eventReceived = true
-        assert.property(event, 'id')
-        assert.property(event, 'kind')
-      }
-
-      const onEose = () => {
-        eoseReceived = true
-      }
-
-      const onClosed = () => {
-        // Handler for closed events
-      }
-
-      await uut.createSubscription(subscriptionId, filters, onEvent, onEose, onClosed)
-
-      // Assert subscription exists
-      assert.isTrue(uut.hasSubscription(subscriptionId))
-
-      // Wait a bit for events/EOSE
-      await new Promise(resolve => setTimeout(resolve, 2000))
-
-      // EOSE should be received (or events)
-      // Note: May not receive events if none exist, but EOSE should come
-      assert.isTrue(eoseReceived || eventReceived)
-
-      // Clean up
-      if (uut.hasSubscription(subscriptionId)) {
-        await uut.closeSubscription(subscriptionId)
-      }
-    })
-
-    it('should prevent duplicate subscriptions', async () => {
-      const subscriptionId = 'test-dup-' + Date.now()
-      const filters = [{ kinds: [1] }]
-
-      await uut.createSubscription(subscriptionId, filters)
-
-      try {
-        await uut.createSubscription(subscriptionId, filters)
-        assert.equal(true, false, 'unexpected result')
-      } catch (err) {
-        assert.include(err.message, 'already exists')
-      }
-
-      // Clean up
-      if (uut.hasSubscription(subscriptionId)) {
-        await uut.closeSubscription(subscriptionId)
-      }
-    })
-
-    it('should handle subscription with no events', async () => {
-      const subscriptionId = 'test-empty-' + Date.now()
-      const filters = [{ kinds: [99999], limit: 1 }] // Unlikely to have events
-
-      let eoseReceived = false
-
-      const onEose = () => {
-        eoseReceived = true
-      }
-
-      await uut.createSubscription(subscriptionId, filters, null, onEose, null)
-
-      // Wait for EOSE
-      await new Promise(resolve => setTimeout(resolve, 2000))
-
-      // Should receive EOSE even with no events
-      assert.isTrue(eoseReceived)
-
-      // Clean up
-      if (uut.hasSubscription(subscriptionId)) {
-        await uut.closeSubscription(subscriptionId)
-      }
-    })
-  })
-
-  describe('#closeSubscription()', () => {
-    it('should successfully close a subscription', async () => {
-      const subscriptionId = 'test-close-' + Date.now()
-      const filters = [{ kinds: [1] }]
-
-      await uut.createSubscription(subscriptionId, filters)
-      assert.isTrue(uut.hasSubscription(subscriptionId))
-
-      await uut.closeSubscription(subscriptionId)
-
-      // Assert subscription is removed
-      assert.isFalse(uut.hasSubscription(subscriptionId))
-    })
-
-    it('should return successfully when closing non-existent subscription (idempotent)', async () => {
-      const subscriptionId = 'non-existent-sub'
-
-      // Should not throw - idempotent operation
-      await uut.closeSubscription(subscriptionId)
-
-      // Should return successfully without error
-      assert.isTrue(true, 'closeSubscription should succeed for non-existent subscription')
-    })
-  })
-
-  describe('#hasSubscription()', () => {
-    it('should return false for non-existent subscription', () => {
-      assert.isFalse(uut.hasSubscription('non-existent'))
-    })
-
-    it('should return true for existing subscription', async () => {
-      const subscriptionId = 'test-has-' + Date.now()
-      const filters = [{ kinds: [1] }]
-
-      assert.isFalse(uut.hasSubscription(subscriptionId))
-      await uut.createSubscription(subscriptionId, filters)
-      assert.isTrue(uut.hasSubscription(subscriptionId))
-
-      // Clean up
-      if (uut.hasSubscription(subscriptionId)) {
-        await uut.closeSubscription(subscriptionId)
-      }
-    })
-  })
-})

package/test/integration/use-cases/publish-event-integration.js

@@ -1,104 +0,0 @@
-/*
-  Integration tests for PublishEventUseCase with real adapter.
-  These tests require a running Nostr relay.
-*/
-
-// npm libraries
-import { assert } from 'chai'
-
-// Unit under test
-import Adapters from '../../../src/adapters/index.js'
-import PublishEventUseCase from '../../../src/use-cases/publish-event.js'
-import { finalizeEvent, generateSecretKey } from 'nostr-tools/pure'
-
-describe('#publish-event-integration.js', () => {
-  let adapters
-  let uut
-
-  before(async () => {
-    // Initialize adapters (will connect to real relay)
-    adapters = new Adapters()
-    await adapters.start()
-
-    uut = new PublishEventUseCase({ adapters })
-  })
-
-  after(async () => {
-    // Clean up adapters - disconnect from all relays
-    if (adapters && adapters.nostrRelays) {
-      await Promise.allSettled(
-        adapters.nostrRelays.map(relay => relay.disconnect())
-      )
-    }
-  })
-
-  describe('#execute()', () => {
-    it('should successfully publish a valid event', async () => {
-      // Generate keys
-      const sk = generateSecretKey()
-
-      // Create event template
-      const eventTemplate = {
-        kind: 1,
-        created_at: Math.floor(Date.now() / 1000),
-        tags: [],
-        content: 'Integration test post from use case'
-      }
-
-      // Sign the event
-      const signedEvent = finalizeEvent(eventTemplate, sk)
-
-      // Execute use case
-      const result = await uut.execute(signedEvent)
-
-      // Assert result
-      assert.property(result, 'accepted')
-      assert.property(result, 'message')
-      assert.property(result, 'eventId')
-      assert.equal(result.eventId, signedEvent.id)
-    })
-
-    it('should reject invalid event structure', async () => {
-      const invalidEvent = {
-        id: 'invalid',
-        pubkey: 'invalid',
-        created_at: Math.floor(Date.now() / 1000),
-        kind: 1,
-        tags: [],
-        content: 'Test',
-        sig: 'invalid'
-      }
-
-      try {
-        await uut.execute(invalidEvent)
-        assert.equal(true, false, 'unexpected result')
-      } catch (err) {
-        assert.include(err.message, 'Invalid event structure')
-      }
-    })
-
-    it('should handle relay rejection', async () => {
-      // Generate keys
-      const sk = generateSecretKey()
-
-      // Create a duplicate event (if we send same event twice)
-      const eventTemplate = {
-        kind: 1,
-        created_at: Math.floor(Date.now() / 1000),
-        tags: [],
-        content: 'Duplicate test post'
-      }
-
-      const signedEvent = finalizeEvent(eventTemplate, sk)
-
-      // Publish first time
-      const result1 = await uut.execute(signedEvent)
-      assert.property(result1, 'accepted')
-
-      // Try to publish again (may be rejected as duplicate)
-      const result2 = await uut.execute(signedEvent)
-      assert.property(result2, 'accepted')
-      // Result may be accepted or rejected depending on relay
-    })
-  })
-})

package/test/integration/use-cases/query-events-integration.js

@@ -1,95 +0,0 @@
-/*
-  Integration tests for QueryEventsUseCase with real adapter.
-  These tests require a running Nostr relay.
-*/
-
-// npm libraries
-import { assert } from 'chai'
-
-// Unit under test
-import Adapters from '../../../src/adapters/index.js'
-import QueryEventsUseCase from '../../../src/use-cases/query-events.js'
-
-describe('#query-events-integration.js', () => {
-  let adapters
-  let uut
-
-  before(async () => {
-    // Initialize adapters (will connect to real relay)
-    adapters = new Adapters()
-    await adapters.start()
-
-    uut = new QueryEventsUseCase({ adapters })
-  })
-
-  after(async () => {
-    // Clean up adapters - disconnect from all relays
-    if (adapters && adapters.nostrRelays) {
-      await Promise.allSettled(
-        adapters.nostrRelays.map(relay => relay.disconnect())
-      )
-    }
-  })
-
-  describe('#execute()', () => {
-    it('should successfully query events', async () => {
-      const filters = [{ kinds: [1], limit: 5 }]
-      const subscriptionId = 'test-query-' + Date.now()
-
-      const events = await uut.execute(filters, subscriptionId)
-
-      // Assert result is an array
-      assert.isArray(events)
-
-      // If events are returned, verify structure
-      if (events.length > 0) {
-        assert.property(events[0], 'id')
-        assert.property(events[0], 'pubkey')
-        assert.property(events[0], 'created_at')
-        assert.property(events[0], 'kind')
-        assert.property(events[0], 'content')
-        assert.equal(events[0].kind, 1)
-      }
-    })
-
-    it('should handle empty results', async () => {
-      // Query for events that likely don't exist
-      const filters = [{ kinds: [99999], limit: 1 }]
-      const subscriptionId = 'test-empty-' + Date.now()
-
-      const events = await uut.execute(filters, subscriptionId)
-
-      // Should return empty array, not throw
-      assert.isArray(events)
-      assert.equal(events.length, 0)
-    })
-
-    it('should handle multiple filters', async function () {
-      // Increase timeout for this test - needs to be longer than use case timeout (30s)
-      this.timeout(35000)
-
-      const filters = [
-        { kinds: [1], limit: 2 },
-        { kinds: [3], limit: 2 }
-      ]
-      const subscriptionId = 'test-multi-' + Date.now()
-
-      const events = await uut.execute(filters, subscriptionId)
-
-      // Should return array (may be empty)
-      assert.isArray(events)
-    })
-
-    it('should timeout if EOSE not received', async () => {
-      // This test may take up to 30 seconds
-      // Use a filter that might not return EOSE quickly
-      const filters = [{ kinds: [1] }] // No limit, might timeout
-      const subscriptionId = 'test-timeout-' + Date.now()
-
-      // Should eventually return (even if empty)
-      const events = await uut.execute(filters, subscriptionId)
-
-      assert.isArray(events)
-    })
-  })
-})

package/test/unit/entities/event-unit.js

@@ -1,139 +0,0 @@
-/*
-  Unit tests for the Event entity.
-*/
-
-// npm libraries
-import { assert } from 'chai'
-
-// Mocking data libraries
-import {
-  mockKind0Event,
-  mockKind1Event,
-  mockKind3Event,
-  mockKind7Event,
-  mockInvalidEventMissingId,
-  mockInvalidEventWrongIdLength,
-  mockInvalidEventMissingPubkey,
-  mockInvalidEventWrongPubkeyLength,
-  mockInvalidEventMissingCreatedAt,
-  mockInvalidEventWrongCreatedAtType,
-  mockInvalidEventMissingKind,
-  mockInvalidEventKindOutOfRange,
-  mockInvalidEventMissingSig,
-  mockInvalidEventWrongSigLength,
-  mockInvalidEventTagsNotArray
-} from '../mocks/event-mocks.js'
-
-// Unit under test
-import Event from '../../../src/entities/event.js'
-
-describe('#event.js', () => {
-  describe('#isValid()', () => {
-    it('should return true for valid kind 0 event', () => {
-      const event = new Event(mockKind0Event)
-      assert.isTrue(event.isValid())
-    })
-
-    it('should return true for valid kind 1 event', () => {
-      const event = new Event(mockKind1Event)
-      assert.isTrue(event.isValid())
-    })
-
-    it('should return true for valid kind 3 event', () => {
-      const event = new Event(mockKind3Event)
-      assert.isTrue(event.isValid())
-    })
-
-    it('should return true for valid kind 7 event', () => {
-      const event = new Event(mockKind7Event)
-      assert.isTrue(event.isValid())
-    })
-
-    it('should return false for event missing id', () => {
-      const event = new Event(mockInvalidEventMissingId)
-      assert.isFalse(event.isValid())
-    })
-
-    it('should return false for event with wrong id length', () => {
-      const event = new Event(mockInvalidEventWrongIdLength)
-      assert.isFalse(event.isValid())
-    })
-
-    it('should return false for event missing pubkey', () => {
-      const event = new Event(mockInvalidEventMissingPubkey)
-      assert.isFalse(event.isValid())
-    })
-
-    it('should return false for event with wrong pubkey length', () => {
-      const event = new Event(mockInvalidEventWrongPubkeyLength)
-      assert.isFalse(event.isValid())
-    })
-
-    it('should return false for event missing created_at', () => {
-      const event = new Event(mockInvalidEventMissingCreatedAt)
-      assert.isFalse(event.isValid())
-    })
-
-    it('should return false for event with wrong created_at type', () => {
-      const event = new Event(mockInvalidEventWrongCreatedAtType)
-      assert.isFalse(event.isValid())
-    })
-
-    it('should return false for event missing kind', () => {
-      const event = new Event(mockInvalidEventMissingKind)
-      assert.isFalse(event.isValid())
-    })
-
-    it('should return false for event with kind out of range', () => {
-      const event = new Event(mockInvalidEventKindOutOfRange)
-      assert.isFalse(event.isValid())
-    })
-
-    it('should return false for event missing sig', () => {
-      const event = new Event(mockInvalidEventMissingSig)
-      assert.isFalse(event.isValid())
-    })
-
-    it('should return false for event with wrong sig length', () => {
-      const event = new Event(mockInvalidEventWrongSigLength)
-      assert.isFalse(event.isValid())
-    })
-
-    it('should return false for event with tags not an array', () => {
-      const event = new Event(mockInvalidEventTagsNotArray)
-      assert.isFalse(event.isValid())
-    })
-  })
-
-  describe('#toJSON()', () => {
-    it('should serialize event to JSON correctly', () => {
-      const event = new Event(mockKind1Event)
-      const json = event.toJSON()
-
-      assert.property(json, 'id')
-      assert.property(json, 'pubkey')
-      assert.property(json, 'created_at')
-      assert.property(json, 'kind')
-      assert.property(json, 'tags')
-      assert.property(json, 'content')
-      assert.property(json, 'sig')
-
-      assert.equal(json.id, mockKind1Event.id)
-      assert.equal(json.pubkey, mockKind1Event.pubkey)
-      assert.equal(json.created_at, mockKind1Event.created_at)
-      assert.equal(json.kind, mockKind1Event.kind)
-      assert.deepEqual(json.tags, mockKind1Event.tags)
-      assert.equal(json.content, mockKind1Event.content)
-      assert.equal(json.sig, mockKind1Event.sig)
-    })
-
-    it('should serialize event with tags correctly', () => {
-      const event = new Event(mockKind3Event)
-      const json = event.toJSON()
-
-      assert.isArray(json.tags)
-      assert.equal(json.tags.length, 1)
-      assert.deepEqual(json.tags, mockKind3Event.tags)
-    })
-  })
-})