@massalabs/gossip-sdk 0.0.2-dev.20260128094509 → 0.0.2-dev.20260128160824

package/test/services/message-deduplication.spec.ts

@@ -1,299 +0,0 @@
-/**
- * Message Deduplication tests
- */
-
-import { describe, it, expect, beforeEach } from 'vitest';
-import {
-  GossipDatabase,
-  MessageStatus,
-  MessageDirection,
-  MessageType,
-  DiscussionStatus,
-  DiscussionDirection,
-} from '../../src/db';
-import { encodeUserId } from '../../src/utils/userId';
-import { defaultSdkConfig, type SdkConfig } from '../../src/config/sdk';
-
-const DEDUP_OWNER_USER_ID = encodeUserId(new Uint8Array(32).fill(1));
-const DEDUP_CONTACT_USER_ID = encodeUserId(new Uint8Array(32).fill(2));
-
-describe('Message Deduplication', () => {
-  let testDb: GossipDatabase;
-
-  beforeEach(async () => {
-    testDb = new GossipDatabase();
-    if (!testDb.isOpen()) {
-      await testDb.open();
-    }
-    await Promise.all(testDb.tables.map(table => table.clear()));
-
-    await testDb.discussions.add({
-      ownerUserId: DEDUP_OWNER_USER_ID,
-      contactUserId: DEDUP_CONTACT_USER_ID,
-      direction: DiscussionDirection.RECEIVED,
-      status: DiscussionStatus.ACTIVE,
-      unreadCount: 0,
-      createdAt: new Date(),
-      updatedAt: new Date(),
-    });
-  });
-
-  describe('isDuplicateMessage (via storeDecryptedMessages)', () => {
-    async function storeIncomingMessage(
-      content: string,
-      timestamp: Date,
-      seeker: Uint8Array
-    ): Promise<number | null> {
-      const existing = await testDb.messages
-        .where('[ownerUserId+contactUserId]')
-        .equals([DEDUP_OWNER_USER_ID, DEDUP_CONTACT_USER_ID])
-        .and(
-          msg =>
-            msg.direction === MessageDirection.INCOMING &&
-            msg.content === content &&
-            msg.timestamp >= new Date(timestamp.getTime() - 30000) &&
-            msg.timestamp <= new Date(timestamp.getTime() + 30000)
-        )
-        .first();
-
-      if (existing) {
-        return null;
-      }
-
-      return await testDb.messages.add({
-        ownerUserId: DEDUP_OWNER_USER_ID,
-        contactUserId: DEDUP_CONTACT_USER_ID,
-        content,
-        type: MessageType.TEXT,
-        direction: MessageDirection.INCOMING,
-        status: MessageStatus.DELIVERED,
-        timestamp,
-        seeker,
-      });
-    }
-
-    it('should store first message normally', async () => {
-      const timestamp = new Date();
-      const id = await storeIncomingMessage(
-        'Hello world',
-        timestamp,
-        new Uint8Array([1, 2, 3])
-      );
-
-      expect(id).not.toBeNull();
-
-      const message = await testDb.messages.get(id!);
-      expect(message?.content).toBe('Hello world');
-    });
-
-    it('should detect duplicate with same content and similar timestamp', async () => {
-      const timestamp = new Date();
-
-      const id1 = await storeIncomingMessage(
-        'Hello world',
-        timestamp,
-        new Uint8Array([1, 2, 3])
-      );
-      expect(id1).not.toBeNull();
-
-      const timestamp2 = new Date(timestamp.getTime() + 5000);
-      const id2 = await storeIncomingMessage(
-        'Hello world',
-        timestamp2,
-        new Uint8Array([4, 5, 6])
-      );
-
-      expect(id2).toBeNull();
-    });
-
-    it('should NOT detect duplicate if content differs', async () => {
-      const timestamp = new Date();
-
-      const id1 = await storeIncomingMessage(
-        'Hello world',
-        timestamp,
-        new Uint8Array([1, 2, 3])
-      );
-      expect(id1).not.toBeNull();
-
-      const id2 = await storeIncomingMessage(
-        'Goodbye world',
-        timestamp,
-        new Uint8Array([4, 5, 6])
-      );
-
-      expect(id2).not.toBeNull();
-    });
-
-    it('should NOT detect duplicate if timestamp outside window', async () => {
-      const timestamp = new Date();
-
-      const id1 = await storeIncomingMessage(
-        'Hello world',
-        timestamp,
-        new Uint8Array([1, 2, 3])
-      );
-      expect(id1).not.toBeNull();
-
-      const timestamp2 = new Date(timestamp.getTime() + 60000);
-      const id2 = await storeIncomingMessage(
-        'Hello world',
-        timestamp2,
-        new Uint8Array([4, 5, 6])
-      );
-
-      expect(id2).not.toBeNull();
-    });
-
-    it('should NOT flag outgoing messages as duplicates of incoming', async () => {
-      const timestamp = new Date();
-
-      await testDb.messages.add({
-        ownerUserId: DEDUP_OWNER_USER_ID,
-        contactUserId: DEDUP_CONTACT_USER_ID,
-        content: 'Hello world',
-        type: MessageType.TEXT,
-        direction: MessageDirection.INCOMING,
-        status: MessageStatus.DELIVERED,
-        timestamp,
-        seeker: new Uint8Array([1, 2, 3]),
-      });
-
-      const outgoingId = await testDb.messages.add({
-        ownerUserId: DEDUP_OWNER_USER_ID,
-        contactUserId: DEDUP_CONTACT_USER_ID,
-        content: 'Hello world',
-        type: MessageType.TEXT,
-        direction: MessageDirection.OUTGOING,
-        status: MessageStatus.SENT,
-        timestamp,
-        seeker: new Uint8Array([4, 5, 6]),
-      });
-
-      expect(outgoingId).toBeDefined();
-    });
-  });
-
-  describe('deduplication window configuration', () => {
-    it('should respect custom deduplication window', async () => {
-      const customConfig: SdkConfig = {
-        ...defaultSdkConfig,
-        messages: {
-          ...defaultSdkConfig.messages,
-          deduplicationWindowMs: 5000,
-        },
-      };
-
-      const timestamp = new Date();
-
-      await testDb.messages.add({
-        ownerUserId: DEDUP_OWNER_USER_ID,
-        contactUserId: DEDUP_CONTACT_USER_ID,
-        content: 'Test message',
-        type: MessageType.TEXT,
-        direction: MessageDirection.INCOMING,
-        status: MessageStatus.DELIVERED,
-        timestamp,
-        seeker: new Uint8Array([1, 2, 3]),
-      });
-
-      const timestamp2 = new Date(timestamp.getTime() + 10000);
-      const windowMs = customConfig.messages.deduplicationWindowMs;
-      const windowStart = new Date(timestamp2.getTime() - windowMs);
-      const windowEnd = new Date(timestamp2.getTime() + windowMs);
-
-      const duplicate = await testDb.messages
-        .where('[ownerUserId+contactUserId]')
-        .equals([DEDUP_OWNER_USER_ID, DEDUP_CONTACT_USER_ID])
-        .and(
-          msg =>
-            msg.direction === MessageDirection.INCOMING &&
-            msg.content === 'Test message' &&
-            msg.timestamp >= windowStart &&
-            msg.timestamp <= windowEnd
-        )
-        .first();
-
-      expect(duplicate).toBeUndefined();
-    });
-  });
-
-  describe('edge cases', () => {
-    it('should handle empty content messages', async () => {
-      const timestamp = new Date();
-
-      const id1 = await testDb.messages.add({
-        ownerUserId: DEDUP_OWNER_USER_ID,
-        contactUserId: DEDUP_CONTACT_USER_ID,
-        content: '',
-        type: MessageType.KEEP_ALIVE,
-        direction: MessageDirection.INCOMING,
-        status: MessageStatus.DELIVERED,
-        timestamp,
-        seeker: new Uint8Array([1, 2, 3]),
-      });
-
-      const windowMs = 30000;
-      const windowStart = new Date(timestamp.getTime() - windowMs);
-      const windowEnd = new Date(timestamp.getTime() + windowMs);
-
-      const duplicate = await testDb.messages
-        .where('[ownerUserId+contactUserId]')
-        .equals([DEDUP_OWNER_USER_ID, DEDUP_CONTACT_USER_ID])
-        .and(
-          msg =>
-            msg.direction === MessageDirection.INCOMING &&
-            msg.content === '' &&
-            msg.timestamp >= windowStart &&
-            msg.timestamp <= windowEnd
-        )
-        .first();
-
-      expect(duplicate?.id).toBe(id1);
-    });
-
-    it('should handle messages from different contacts separately', async () => {
-      const timestamp = new Date();
-      const CONTACT_2_USER_ID = encodeUserId(new Uint8Array(32).fill(3));
-
-      await testDb.discussions.add({
-        ownerUserId: DEDUP_OWNER_USER_ID,
-        contactUserId: CONTACT_2_USER_ID,
-        direction: DiscussionDirection.RECEIVED,
-        status: DiscussionStatus.ACTIVE,
-        unreadCount: 0,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-      });
-
-      await testDb.messages.add({
-        ownerUserId: DEDUP_OWNER_USER_ID,
-        contactUserId: DEDUP_CONTACT_USER_ID,
-        content: 'Hello',
-        type: MessageType.TEXT,
-        direction: MessageDirection.INCOMING,
-        status: MessageStatus.DELIVERED,
-        timestamp,
-        seeker: new Uint8Array([1, 2, 3]),
-      });
-
-      const windowMs = 30000;
-      const windowStart = new Date(timestamp.getTime() - windowMs);
-      const windowEnd = new Date(timestamp.getTime() + windowMs);
-
-      const duplicateFromContact2 = await testDb.messages
-        .where('[ownerUserId+contactUserId]')
-        .equals([DEDUP_OWNER_USER_ID, CONTACT_2_USER_ID])
-        .and(
-          msg =>
-            msg.direction === MessageDirection.INCOMING &&
-            msg.content === 'Hello' &&
-            msg.timestamp >= windowStart &&
-            msg.timestamp <= windowEnd
-        )
-        .first();
-
-      expect(duplicateFromContact2).toBeUndefined();
-    });
-  });
-});

package/test/services/message-startup.spec.ts

@@ -1,331 +0,0 @@
-/**
- * Message startup behavior tests
- *
- * SENDING reset on startup, messages from unknown peers, seeker stabilization.
- */
-
-import { describe, it, expect, beforeEach } from 'vitest';
-import {
-  GossipDatabase,
-  MessageStatus,
-  MessageDirection,
-  MessageType,
-  DiscussionStatus,
-  DiscussionDirection,
-} from '../../src/db';
-import { encodeUserId } from '../../src/utils/userId';
-import { defaultSdkConfig } from '../../src/config/sdk';
-
-// ============================================================================
-// SENDING reset on startup
-// ============================================================================
-
-const RESET_OWNER_USER_ID = encodeUserId(new Uint8Array(32).fill(1));
-const RESET_CONTACT_USER_ID = encodeUserId(new Uint8Array(32).fill(2));
-
-describe('SENDING Reset on Startup', () => {
-  let testDb: GossipDatabase;
-
-  beforeEach(async () => {
-    testDb = new GossipDatabase();
-    if (!testDb.isOpen()) {
-      await testDb.open();
-    }
-    await Promise.all(testDb.tables.map(table => table.clear()));
-  });
-
-  describe('resetStuckSendingMessages behavior', () => {
-    async function resetStuckSendingMessages(): Promise<number> {
-      return await testDb.messages
-        .where('status')
-        .equals(MessageStatus.SENDING)
-        .modify({
-          status: MessageStatus.WAITING_SESSION,
-          encryptedMessage: undefined,
-          seeker: undefined,
-        });
-    }
-
-    it('should reset SENDING messages to WAITING_SESSION', async () => {
-      const messageId = await testDb.messages.add({
-        ownerUserId: RESET_OWNER_USER_ID,
-        contactUserId: RESET_CONTACT_USER_ID,
-        content: 'Test message',
-        type: MessageType.TEXT,
-        direction: MessageDirection.OUTGOING,
-        status: MessageStatus.SENDING,
-        timestamp: new Date(),
-        encryptedMessage: new Uint8Array([1, 2, 3]),
-        seeker: new Uint8Array([4, 5, 6]),
-      });
-
-      const count = await resetStuckSendingMessages();
-
-      expect(count).toBe(1);
-
-      const message = await testDb.messages.get(messageId);
-      expect(message?.status).toBe(MessageStatus.WAITING_SESSION);
-      expect(message?.encryptedMessage).toBeUndefined();
-      expect(message?.seeker).toBeUndefined();
-    });
-
-    it('should clear encryptedMessage and seeker for re-encryption', async () => {
-      const originalEncrypted = new Uint8Array([10, 20, 30, 40]);
-      const originalSeeker = new Uint8Array([50, 60, 70, 80]);
-
-      const messageId = await testDb.messages.add({
-        ownerUserId: RESET_OWNER_USER_ID,
-        contactUserId: RESET_CONTACT_USER_ID,
-        content: 'Message with encryption data',
-        type: MessageType.TEXT,
-        direction: MessageDirection.OUTGOING,
-        status: MessageStatus.SENDING,
-        timestamp: new Date(),
-        encryptedMessage: originalEncrypted,
-        seeker: originalSeeker,
-      });
-
-      await resetStuckSendingMessages();
-
-      const message = await testDb.messages.get(messageId);
-
-      expect(message?.encryptedMessage).toBeUndefined();
-      expect(message?.seeker).toBeUndefined();
-      expect(message?.content).toBe('Message with encryption data');
-    });
-
-    it('should NOT affect messages in other statuses', async () => {
-      const waitingId = await testDb.messages.add({
-        ownerUserId: RESET_OWNER_USER_ID,
-        contactUserId: RESET_CONTACT_USER_ID,
-        content: 'Waiting',
-        type: MessageType.TEXT,
-        direction: MessageDirection.OUTGOING,
-        status: MessageStatus.WAITING_SESSION,
-        timestamp: new Date(),
-      });
-
-      const sentId = await testDb.messages.add({
-        ownerUserId: RESET_OWNER_USER_ID,
-        contactUserId: RESET_CONTACT_USER_ID,
-        content: 'Sent',
-        type: MessageType.TEXT,
-        direction: MessageDirection.OUTGOING,
-        status: MessageStatus.SENT,
-        timestamp: new Date(),
-        seeker: new Uint8Array([1, 2, 3]),
-      });
-
-      const deliveredId = await testDb.messages.add({
-        ownerUserId: RESET_OWNER_USER_ID,
-        contactUserId: RESET_CONTACT_USER_ID,
-        content: 'Delivered',
-        type: MessageType.TEXT,
-        direction: MessageDirection.OUTGOING,
-        status: MessageStatus.DELIVERED,
-        timestamp: new Date(),
-        seeker: new Uint8Array([4, 5, 6]),
-      });
-
-      const failedId = await testDb.messages.add({
-        ownerUserId: RESET_OWNER_USER_ID,
-        contactUserId: RESET_CONTACT_USER_ID,
-        content: 'Failed',
-        type: MessageType.TEXT,
-        direction: MessageDirection.OUTGOING,
-        status: MessageStatus.FAILED,
-        timestamp: new Date(),
-      });
-
-      const count = await resetStuckSendingMessages();
-
-      expect(count).toBe(0);
-      expect((await testDb.messages.get(waitingId))?.status).toBe(
-        MessageStatus.WAITING_SESSION
-      );
-      expect((await testDb.messages.get(sentId))?.status).toBe(
-        MessageStatus.SENT
-      );
-      expect((await testDb.messages.get(deliveredId))?.status).toBe(
-        MessageStatus.DELIVERED
-      );
-      expect((await testDb.messages.get(failedId))?.status).toBe(
-        MessageStatus.FAILED
-      );
-    });
-
-    it('should reset multiple SENDING messages', async () => {
-      await testDb.messages.bulkAdd([
-        {
-          ownerUserId: RESET_OWNER_USER_ID,
-          contactUserId: RESET_CONTACT_USER_ID,
-          content: 'Message 1',
-          type: MessageType.TEXT,
-          direction: MessageDirection.OUTGOING,
-          status: MessageStatus.SENDING,
-          timestamp: new Date(),
-          encryptedMessage: new Uint8Array([1]),
-          seeker: new Uint8Array([1]),
-        },
-        {
-          ownerUserId: RESET_OWNER_USER_ID,
-          contactUserId: RESET_CONTACT_USER_ID,
-          content: 'Message 2',
-          type: MessageType.TEXT,
-          direction: MessageDirection.OUTGOING,
-          status: MessageStatus.SENDING,
-          timestamp: new Date(),
-          encryptedMessage: new Uint8Array([2]),
-          seeker: new Uint8Array([2]),
-        },
-        {
-          ownerUserId: RESET_OWNER_USER_ID,
-          contactUserId: RESET_CONTACT_USER_ID,
-          content: 'Message 3',
-          type: MessageType.TEXT,
-          direction: MessageDirection.OUTGOING,
-          status: MessageStatus.SENDING,
-          timestamp: new Date(),
-          encryptedMessage: new Uint8Array([3]),
-          seeker: new Uint8Array([3]),
-        },
-      ]);
-
-      const count = await resetStuckSendingMessages();
-
-      expect(count).toBe(3);
-
-      const messages = await testDb.messages.toArray();
-      expect(
-        messages.every(m => m.status === MessageStatus.WAITING_SESSION)
-      ).toBe(true);
-      expect(messages.every(m => m.encryptedMessage === undefined)).toBe(true);
-      expect(messages.every(m => m.seeker === undefined)).toBe(true);
-    });
-
-    it('should handle empty database gracefully', async () => {
-      const count = await resetStuckSendingMessages();
-      expect(count).toBe(0);
-    });
-  });
-});
-
-// ============================================================================
-// Messages from Unknown Peer
-// ============================================================================
-
-const EDGE_OWNER_USER_ID = encodeUserId(new Uint8Array(32).fill(1));
-const EDGE_CONTACT_USER_ID = encodeUserId(new Uint8Array(32).fill(2));
-const EDGE_UNKNOWN_USER_ID = encodeUserId(new Uint8Array(32).fill(99));
-
-describe('Messages from Unknown Peer', () => {
-  let testDb: GossipDatabase;
-
-  beforeEach(async () => {
-    testDb = new GossipDatabase();
-    await testDb.open();
-    await Promise.all(testDb.tables.map(table => table.clear()));
-
-    await testDb.discussions.add({
-      ownerUserId: EDGE_OWNER_USER_ID,
-      contactUserId: EDGE_CONTACT_USER_ID,
-      direction: DiscussionDirection.RECEIVED,
-      status: DiscussionStatus.ACTIVE,
-      unreadCount: 0,
-      createdAt: new Date(),
-      updatedAt: new Date(),
-    });
-  });
-
-  it('should not have discussion for unknown peer', async () => {
-    const discussion = await testDb.getDiscussionByOwnerAndContact(
-      EDGE_OWNER_USER_ID,
-      EDGE_UNKNOWN_USER_ID
-    );
-
-    expect(discussion).toBeUndefined();
-  });
-
-  it('should have discussion for known peer', async () => {
-    const discussion = await testDb.getDiscussionByOwnerAndContact(
-      EDGE_OWNER_USER_ID,
-      EDGE_CONTACT_USER_ID
-    );
-
-    expect(discussion).toBeDefined();
-    expect(discussion?.contactUserId).toBe(EDGE_CONTACT_USER_ID);
-  });
-});
-
-// ============================================================================
-// Seeker Stabilization Logic
-// ============================================================================
-
-describe('Seeker Stabilization Logic', () => {
-  it('should detect when seekers are the same (stabilized)', () => {
-    const seekers1 = new Set(['seeker1', 'seeker2', 'seeker3']);
-    const seekers2 = new Set(['seeker1', 'seeker2', 'seeker3']);
-
-    const areSame =
-      seekers1.size === seekers2.size &&
-      [...seekers1].every(s => seekers2.has(s));
-
-    expect(areSame).toBe(true);
-  });
-
-  it('should detect when seekers changed (not stabilized)', () => {
-    const seekers1 = new Set(['seeker1', 'seeker2']);
-    const seekers2 = new Set(['seeker1', 'seeker2', 'seeker3']);
-
-    const areSame =
-      seekers1.size === seekers2.size &&
-      [...seekers1].every(s => seekers2.has(s));
-
-    expect(areSame).toBe(false);
-  });
-
-  it('should detect when seekers reduced', () => {
-    const seekers1 = new Set(['seeker1', 'seeker2', 'seeker3']);
-    const seekers2 = new Set(['seeker1', 'seeker2']);
-
-    const areSame =
-      seekers1.size === seekers2.size &&
-      [...seekers1].every(s => seekers2.has(s));
-
-    expect(areSame).toBe(false);
-  });
-
-  it('should handle empty seeker sets', () => {
-    const seekers1 = new Set<string>();
-    const seekers2 = new Set<string>();
-
-    const areSame =
-      seekers1.size === seekers2.size &&
-      [...seekers1].every(s => seekers2.has(s));
-
-    expect(areSame).toBe(true);
-  });
-
-  it('should respect maxFetchIterations limit', () => {
-    const maxIterations = defaultSdkConfig.messages.maxFetchIterations;
-    let iterations = 0;
-    const seekersNeverStabilize = () => new Set([`seeker${iterations++}`]);
-
-    let previousSeekers = new Set<string>();
-    let loopCount = 0;
-
-    while (loopCount < maxIterations) {
-      const currentSeekers = seekersNeverStabilize();
-      const stabilized =
-        previousSeekers.size === currentSeekers.size &&
-        [...previousSeekers].every(s => currentSeekers.has(s));
-
-      if (stabilized) break;
-
-      previousSeekers = currentSeekers;
-      loopCount++;
-    }
-
-    expect(loopCount).toBe(maxIterations);
-  });
-});