@massalabs/gossip-sdk 0.0.1

package/test/config/sdk.spec.ts

@@ -0,0 +1,163 @@
+/**
+ * SDK Config tests
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  defaultSdkConfig,
+  mergeConfig,
+  type SdkConfig,
+  type DeepPartial,
+} from '../../src/config/sdk';
+
+describe('SDK Config', () => {
+  describe('defaultSdkConfig', () => {
+    it('should have correct default protocol values', () => {
+      expect(defaultSdkConfig.protocol.timeout).toBe(10000);
+      expect(defaultSdkConfig.protocol.retryAttempts).toBe(3);
+      expect(defaultSdkConfig.protocol.baseUrl).toBeUndefined();
+    });
+
+    it('should have correct default polling values', () => {
+      expect(defaultSdkConfig.polling.enabled).toBe(false);
+      expect(defaultSdkConfig.polling.messagesIntervalMs).toBe(5000);
+      expect(defaultSdkConfig.polling.announcementsIntervalMs).toBe(10000);
+      expect(defaultSdkConfig.polling.sessionRefreshIntervalMs).toBe(30000);
+    });
+
+    it('should have correct default messages values', () => {
+      expect(defaultSdkConfig.messages.fetchDelayMs).toBe(100);
+      expect(defaultSdkConfig.messages.maxFetchIterations).toBe(30);
+    });
+
+    it('should have correct default announcements values', () => {
+      expect(defaultSdkConfig.announcements.fetchLimit).toBe(500);
+      expect(defaultSdkConfig.announcements.brokenThresholdMs).toBe(
+        60 * 60 * 1000
+      );
+    });
+  });
+
+  describe('mergeConfig', () => {
+    it('should return defaults when no partial provided', () => {
+      const config = mergeConfig();
+      expect(config).toEqual(defaultSdkConfig);
+    });
+
+    it('should return defaults when undefined provided', () => {
+      const config = mergeConfig(undefined);
+      expect(config).toEqual(defaultSdkConfig);
+    });
+
+    it('should merge partial protocol config', () => {
+      const partial: DeepPartial<SdkConfig> = {
+        protocol: {
+          timeout: 5000,
+        },
+      };
+
+      const config = mergeConfig(partial);
+
+      expect(config.protocol.timeout).toBe(5000);
+      expect(config.protocol.retryAttempts).toBe(3);
+      expect(config.polling.enabled).toBe(false);
+    });
+
+    it('should merge partial polling config', () => {
+      const partial: DeepPartial<SdkConfig> = {
+        polling: {
+          enabled: true,
+          messagesIntervalMs: 2000,
+        },
+      };
+
+      const config = mergeConfig(partial);
+
+      expect(config.polling.enabled).toBe(true);
+      expect(config.polling.messagesIntervalMs).toBe(2000);
+      expect(config.polling.announcementsIntervalMs).toBe(10000);
+      expect(config.polling.sessionRefreshIntervalMs).toBe(30000);
+    });
+
+    it('should merge partial messages config', () => {
+      const partial: DeepPartial<SdkConfig> = {
+        messages: {
+          maxFetchIterations: 50,
+        },
+      };
+
+      const config = mergeConfig(partial);
+
+      expect(config.messages.maxFetchIterations).toBe(50);
+      expect(config.messages.fetchDelayMs).toBe(100);
+    });
+
+    it('should merge partial announcements config', () => {
+      const partial: DeepPartial<SdkConfig> = {
+        announcements: {
+          brokenThresholdMs: 30 * 60 * 1000,
+        },
+      };
+
+      const config = mergeConfig(partial);
+
+      expect(config.announcements.brokenThresholdMs).toBe(30 * 60 * 1000);
+      expect(config.announcements.fetchLimit).toBe(500);
+    });
+
+    it('should merge multiple sections at once', () => {
+      const partial: DeepPartial<SdkConfig> = {
+        protocol: {
+          baseUrl: 'https://custom.api.com',
+        },
+        polling: {
+          enabled: true,
+        },
+        messages: {
+          fetchDelayMs: 50,
+        },
+        announcements: {
+          fetchLimit: 1000,
+        },
+      };
+
+      const config = mergeConfig(partial);
+
+      expect(config.protocol.baseUrl).toBe('https://custom.api.com');
+      expect(config.polling.enabled).toBe(true);
+      expect(config.messages.fetchDelayMs).toBe(50);
+      expect(config.announcements.fetchLimit).toBe(1000);
+      expect(config.protocol.timeout).toBe(10000);
+      expect(config.polling.messagesIntervalMs).toBe(5000);
+    });
+
+    it('should not mutate the original defaults', () => {
+      const originalTimeout = defaultSdkConfig.protocol.timeout;
+
+      mergeConfig({
+        protocol: { timeout: 1234 },
+      });
+
+      expect(defaultSdkConfig.protocol.timeout).toBe(originalTimeout);
+    });
+  });
+});
+
+describe('Max Fetch Iterations Limit', () => {
+  it('should respect maxFetchIterations config', async () => {
+    const config: SdkConfig = {
+      ...defaultSdkConfig,
+      messages: {
+        ...defaultSdkConfig.messages,
+        maxFetchIterations: 5,
+        fetchDelayMs: 0,
+      },
+    };
+
+    expect(config.messages.maxFetchIterations).toBe(5);
+  });
+
+  it('should have default maxFetchIterations of 30', () => {
+    expect(defaultSdkConfig.messages.maxFetchIterations).toBe(30);
+  });
+});

package/test/db/helpers.spec.ts

@@ -0,0 +1,142 @@
+/**
+ * Database helper methods tests
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import {
+  db,
+  DiscussionDirection,
+  DiscussionStatus,
+  MessageDirection,
+  MessageStatus,
+  MessageType,
+} from '../../src/db';
+import { encodeUserId } from '../../src/utils/userId';
+
+const OWNER_USER_ID = encodeUserId(new Uint8Array(32).fill(6));
+const CONTACT_USER_ID = encodeUserId(new Uint8Array(32).fill(7));
+
+describe('Database helper methods', () => {
+  beforeEach(async () => {
+    if (!db.isOpen()) {
+      await db.open();
+    }
+    await Promise.all(db.tables.map(table => table.clear()));
+  });
+
+  it('returns discussions sorted by last message timestamp', async () => {
+    await db.discussions.add({
+      ownerUserId: OWNER_USER_ID,
+      contactUserId: CONTACT_USER_ID,
+      direction: DiscussionDirection.INITIATED,
+      status: DiscussionStatus.ACTIVE,
+      unreadCount: 0,
+      lastMessageTimestamp: new Date('2024-01-01'),
+      createdAt: new Date('2024-01-01'),
+      updatedAt: new Date('2024-01-01'),
+    });
+
+    await db.discussions.add({
+      ownerUserId: OWNER_USER_ID,
+      contactUserId: encodeUserId(new Uint8Array(32).fill(8)),
+      direction: DiscussionDirection.INITIATED,
+      status: DiscussionStatus.ACTIVE,
+      unreadCount: 0,
+      lastMessageTimestamp: new Date('2024-02-01'),
+      createdAt: new Date('2024-02-01'),
+      updatedAt: new Date('2024-02-01'),
+    });
+
+    const discussions = await db.getDiscussionsByOwner(OWNER_USER_ID);
+    expect(discussions[0].lastMessageTimestamp?.toISOString()).toBe(
+      new Date('2024-02-01').toISOString()
+    );
+  });
+
+  it('returns active discussions only', async () => {
+    await db.discussions.add({
+      ownerUserId: OWNER_USER_ID,
+      contactUserId: CONTACT_USER_ID,
+      direction: DiscussionDirection.INITIATED,
+      status: DiscussionStatus.ACTIVE,
+      unreadCount: 0,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    });
+
+    await db.discussions.add({
+      ownerUserId: OWNER_USER_ID,
+      contactUserId: encodeUserId(new Uint8Array(32).fill(9)),
+      direction: DiscussionDirection.RECEIVED,
+      status: DiscussionStatus.PENDING,
+      unreadCount: 0,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    });
+
+    const active = await db.getActiveDiscussionsByOwner(OWNER_USER_ID);
+    expect(active.length).toBe(1);
+    expect(active[0].status).toBe(DiscussionStatus.ACTIVE);
+  });
+
+  it('aggregates unread counts across discussions', async () => {
+    await db.discussions.add({
+      ownerUserId: OWNER_USER_ID,
+      contactUserId: CONTACT_USER_ID,
+      direction: DiscussionDirection.INITIATED,
+      status: DiscussionStatus.ACTIVE,
+      unreadCount: 2,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    });
+
+    await db.discussions.add({
+      ownerUserId: OWNER_USER_ID,
+      contactUserId: encodeUserId(new Uint8Array(32).fill(10)),
+      direction: DiscussionDirection.RECEIVED,
+      status: DiscussionStatus.ACTIVE,
+      unreadCount: 3,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    });
+
+    const unread = await db.getUnreadCountByOwner(OWNER_USER_ID);
+    expect(unread).toBe(5);
+  });
+
+  it('marks delivered incoming messages as read', async () => {
+    await db.discussions.add({
+      ownerUserId: OWNER_USER_ID,
+      contactUserId: CONTACT_USER_ID,
+      direction: DiscussionDirection.INITIATED,
+      status: DiscussionStatus.ACTIVE,
+      unreadCount: 1,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    });
+
+    await db.messages.add({
+      ownerUserId: OWNER_USER_ID,
+      contactUserId: CONTACT_USER_ID,
+      content: 'Hello',
+      type: MessageType.TEXT,
+      direction: MessageDirection.INCOMING,
+      status: MessageStatus.DELIVERED,
+      timestamp: new Date(),
+    });
+
+    await db.markMessagesAsRead(OWNER_USER_ID, CONTACT_USER_ID);
+
+    const messages = await db.messages
+      .where('[ownerUserId+contactUserId+status]')
+      .equals([OWNER_USER_ID, CONTACT_USER_ID, MessageStatus.READ])
+      .toArray();
+    expect(messages.length).toBe(1);
+
+    const discussion = await db.getDiscussionByOwnerAndContact(
+      OWNER_USER_ID,
+      CONTACT_USER_ID
+    );
+    expect(discussion?.unreadCount).toBe(0);
+  });
+});

package/test/db/operations.spec.ts

@@ -0,0 +1,128 @@
+/**
+ * Database operations tests
+ */
+
+import { describe, it, expect, beforeEach, afterAll } from 'vitest';
+import {
+  GossipDatabase,
+  DiscussionStatus,
+  DiscussionDirection,
+  MessageDirection,
+  MessageStatus,
+  MessageType,
+} from '../../src/db';
+
+const TEST_OWNER_USER_ID = 'gossip1testowner';
+const TEST_CONTACT_USER_ID = 'gossip1testcontact';
+
+const testDb = new GossipDatabase();
+
+describe('Simple Database Tests', () => {
+  beforeEach(async () => {
+    if (!testDb.isOpen()) {
+      await testDb.open();
+    }
+    await testDb.discussions.clear();
+    await testDb.messages.clear();
+    await testDb.contacts.clear();
+    await testDb.pendingAnnouncements.clear();
+  });
+
+  afterAll(async () => {
+    await testDb.close();
+  });
+
+  it('should create and retrieve a discussion', async () => {
+    const discussionId = await testDb.discussions.add({
+      ownerUserId: TEST_OWNER_USER_ID,
+      contactUserId: TEST_CONTACT_USER_ID,
+      direction: DiscussionDirection.INITIATED,
+      status: DiscussionStatus.PENDING,
+      unreadCount: 0,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    });
+
+    const discussion = await testDb.discussions.get(discussionId);
+    expect(discussion?.direction).toBe(DiscussionDirection.INITIATED);
+    expect(discussion?.status).toBe(DiscussionStatus.PENDING);
+  });
+
+  it('should update discussion status', async () => {
+    const discussionId = await testDb.discussions.add({
+      ownerUserId: TEST_OWNER_USER_ID,
+      contactUserId: TEST_CONTACT_USER_ID,
+      direction: DiscussionDirection.INITIATED,
+      status: DiscussionStatus.PENDING,
+      unreadCount: 0,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    });
+
+    await testDb.discussions.update(discussionId, {
+      status: DiscussionStatus.ACTIVE,
+    });
+
+    const discussion = await testDb.discussions.get(discussionId);
+    expect(discussion?.status).toBe(DiscussionStatus.ACTIVE);
+  });
+
+  it('should create and retrieve a message', async () => {
+    const messageId = await testDb.messages.add({
+      ownerUserId: TEST_OWNER_USER_ID,
+      contactUserId: TEST_CONTACT_USER_ID,
+      content: 'Test message',
+      type: MessageType.TEXT,
+      direction: MessageDirection.OUTGOING,
+      status: MessageStatus.SENDING,
+      timestamp: new Date(),
+    });
+
+    const message = await testDb.messages.get(messageId);
+    expect(message?.content).toBe('Test message');
+    expect(message?.status).toBe(MessageStatus.SENDING);
+  });
+
+  it('should reset SENDING messages to FAILED', async () => {
+    await testDb.messages.add({
+      ownerUserId: TEST_OWNER_USER_ID,
+      contactUserId: TEST_CONTACT_USER_ID,
+      content: 'Stuck message',
+      type: MessageType.TEXT,
+      direction: MessageDirection.OUTGOING,
+      status: MessageStatus.SENDING,
+      timestamp: new Date(),
+    });
+
+    const count = await testDb.messages
+      .where('status')
+      .equals(MessageStatus.SENDING)
+      .modify({ status: MessageStatus.FAILED });
+
+    expect(count).toBe(1);
+
+    const messages = await testDb.messages
+      .where('status')
+      .equals(MessageStatus.FAILED)
+      .toArray();
+    expect(messages.length).toBe(1);
+  });
+
+  it('should store announcement bytes for retry', async () => {
+    const announcement = new Uint8Array([1, 2, 3, 4, 5]);
+    const discussionId = await testDb.discussions.add({
+      ownerUserId: TEST_OWNER_USER_ID,
+      contactUserId: TEST_CONTACT_USER_ID,
+      direction: DiscussionDirection.INITIATED,
+      status: DiscussionStatus.SEND_FAILED,
+      initiationAnnouncement: announcement,
+      unreadCount: 0,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    });
+
+    const discussion = await testDb.discussions.get(discussionId);
+    expect(discussion?.initiationAnnouncement).toBeDefined();
+    expect(discussion?.initiationAnnouncement?.length).toBe(5);
+  });
+});