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

package/test/services/auth.spec.ts

@@ -1,311 +0,0 @@
-/**
- * AuthService tests
- */
-
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import {
-  AuthService,
-  getPublicKeyErrorMessage,
-  PUBLIC_KEY_NOT_FOUND_ERROR,
-  PUBLIC_KEY_NOT_FOUND_MESSAGE,
-  FAILED_TO_FETCH_ERROR,
-  FAILED_TO_FETCH_MESSAGE,
-  FAILED_TO_RETRIEVE_CONTACT_PUBLIC_KEY_ERROR,
-} from '../../src/services/auth';
-import { db, UserProfile } from '../../src/db';
-import type { IMessageProtocol } from '../../src/api/messageProtocol/types';
-import {
-  UserPublicKeys,
-  UserKeys,
-  generate_user_keys,
-} from '../../src/assets/generated/wasm/gossip_wasm';
-import { encodeUserId } from '../../src/utils/userId';
-import { encodeToBase64, decodeFromBase64 } from '../../src/utils/base64';
-import { ensureWasmInitialized } from '../../src/wasm';
-
-function createMockProtocol(
-  overrides: Partial<IMessageProtocol> = {}
-): IMessageProtocol {
-  return {
-    fetchMessages: vi.fn().mockResolvedValue([]),
-    sendMessage: vi.fn().mockResolvedValue(undefined),
-    sendAnnouncement: vi.fn().mockResolvedValue('1'),
-    fetchAnnouncements: vi.fn().mockResolvedValue([]),
-    fetchPublicKeyByUserId: vi.fn().mockResolvedValue(''),
-    postPublicKey: vi.fn().mockResolvedValue('hash'),
-    changeNode: vi.fn().mockResolvedValue({ success: true }),
-    ...overrides,
-  };
-}
-
-function createUserProfile(
-  userId: string,
-  overrides: Partial<UserProfile> = {}
-): UserProfile {
-  return {
-    userId,
-    username: 'testuser',
-    security: {
-      encKeySalt: new Uint8Array(32),
-      authMethod: 'password' as const,
-      mnemonicBackup: {
-        encryptedMnemonic: new Uint8Array(64),
-        createdAt: new Date(),
-        backedUp: false,
-      },
-    },
-    session: new Uint8Array(32),
-    status: 'online' as const,
-    lastSeen: new Date(),
-    createdAt: new Date(),
-    updatedAt: new Date(),
-    ...overrides,
-  };
-}
-
-describe('getPublicKeyErrorMessage', () => {
-  it('should return specific message for "Public key not found" error', () => {
-    const error = new Error(PUBLIC_KEY_NOT_FOUND_ERROR);
-    const result = getPublicKeyErrorMessage(error);
-    expect(result).toBe(PUBLIC_KEY_NOT_FOUND_MESSAGE);
-  });
-
-  it('should return specific message for "Failed to fetch" error', () => {
-    const error = new Error(FAILED_TO_FETCH_ERROR);
-    const result = getPublicKeyErrorMessage(error);
-    expect(result).toBe(FAILED_TO_FETCH_MESSAGE);
-  });
-
-  it('should return generic message with error details for other errors', () => {
-    const error = new Error('Network timeout');
-    const result = getPublicKeyErrorMessage(error);
-    expect(result).toContain(FAILED_TO_RETRIEVE_CONTACT_PUBLIC_KEY_ERROR);
-    expect(result).toContain('Network timeout');
-  });
-
-  it('should handle non-Error objects', () => {
-    const error = 'String error';
-    const result = getPublicKeyErrorMessage(error);
-    expect(result).toContain(FAILED_TO_RETRIEVE_CONTACT_PUBLIC_KEY_ERROR);
-    expect(result).toContain('String error');
-  });
-
-  it('should handle null/undefined gracefully', () => {
-    const result1 = getPublicKeyErrorMessage(null);
-    const result2 = getPublicKeyErrorMessage(undefined);
-    expect(result1).toContain(FAILED_TO_RETRIEVE_CONTACT_PUBLIC_KEY_ERROR);
-    expect(result2).toContain(FAILED_TO_RETRIEVE_CONTACT_PUBLIC_KEY_ERROR);
-  });
-});
-
-describe('AuthService', () => {
-  let mockMessageProtocol: IMessageProtocol;
-  let authService: AuthService;
-  let testUserId: string;
-  let testUserIdBytes: Uint8Array;
-  let testPublicKeys: UserPublicKeys;
-  let userKeys: UserKeys | null = null;
-
-  beforeEach(async () => {
-    await ensureWasmInitialized();
-
-    if (!db.isOpen()) {
-      await db.open();
-    }
-    await Promise.all(db.tables.map(table => table.clear()));
-
-    testUserIdBytes = new Uint8Array(32).fill(42);
-    testUserId = encodeUserId(testUserIdBytes);
-
-    userKeys = generate_user_keys('test-passphrase-' + Date.now());
-    testPublicKeys = userKeys.public_keys();
-
-    mockMessageProtocol = createMockProtocol();
-    authService = new AuthService(db, mockMessageProtocol);
-  });
-
-  afterEach(async () => {
-    if (testPublicKeys) {
-      testPublicKeys.free();
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      testPublicKeys = null as any;
-    }
-    if (userKeys) {
-      userKeys.free();
-      userKeys = null;
-    }
-    vi.clearAllMocks();
-  });
-
-  describe('fetchPublicKeyByUserId', () => {
-    it('should successfully fetch and decode public key', async () => {
-      const publicKeyBytes = testPublicKeys.to_bytes();
-      const base64PublicKey = encodeToBase64(publicKeyBytes);
-
-      vi.mocked(mockMessageProtocol.fetchPublicKeyByUserId).mockResolvedValue(
-        base64PublicKey
-      );
-
-      const result = await authService.fetchPublicKeyByUserId(testUserId);
-
-      expect(result).toHaveProperty('publicKey');
-      expect(result).not.toHaveProperty('error');
-      expect(result.publicKey).toBeInstanceOf(UserPublicKeys);
-      expect(mockMessageProtocol.fetchPublicKeyByUserId).toHaveBeenCalledWith(
-        testUserIdBytes
-      );
-    });
-
-    it('should return error when public key is not found', async () => {
-      const error = new Error(PUBLIC_KEY_NOT_FOUND_ERROR);
-      vi.mocked(mockMessageProtocol.fetchPublicKeyByUserId).mockRejectedValue(
-        error
-      );
-
-      const result = await authService.fetchPublicKeyByUserId(testUserId);
-
-      expect(result).toHaveProperty('error');
-      expect(result).not.toHaveProperty('publicKey');
-      expect(result.error).toBe(PUBLIC_KEY_NOT_FOUND_MESSAGE);
-    });
-
-    it('should return error when fetch fails', async () => {
-      const error = new Error(FAILED_TO_FETCH_ERROR);
-      vi.mocked(mockMessageProtocol.fetchPublicKeyByUserId).mockRejectedValue(
-        error
-      );
-
-      const result = await authService.fetchPublicKeyByUserId(testUserId);
-
-      expect(result).toHaveProperty('error');
-      expect(result.error).toBe(FAILED_TO_FETCH_MESSAGE);
-    });
-
-    it('should return error for network errors', async () => {
-      const error = new Error('Network timeout');
-      vi.mocked(mockMessageProtocol.fetchPublicKeyByUserId).mockRejectedValue(
-        error
-      );
-
-      const result = await authService.fetchPublicKeyByUserId(testUserId);
-
-      expect(result).toHaveProperty('error');
-      expect(result.error).toContain(
-        FAILED_TO_RETRIEVE_CONTACT_PUBLIC_KEY_ERROR
-      );
-      expect(result.error).toContain('Network timeout');
-    });
-
-    it('should decode userId correctly before fetching', async () => {
-      const publicKeyBytes = testPublicKeys.to_bytes();
-      const base64PublicKey = encodeToBase64(publicKeyBytes);
-
-      vi.mocked(mockMessageProtocol.fetchPublicKeyByUserId).mockResolvedValue(
-        base64PublicKey
-      );
-
-      await authService.fetchPublicKeyByUserId(testUserId);
-
-      expect(mockMessageProtocol.fetchPublicKeyByUserId).toHaveBeenCalledTimes(
-        1
-      );
-      const calledWith = vi.mocked(mockMessageProtocol.fetchPublicKeyByUserId)
-        .mock.calls[0][0];
-      expect(Array.from(calledWith)).toEqual(Array.from(testUserIdBytes));
-    });
-  });
-
-  describe('ensurePublicKeyPublished', () => {
-    it('should not publish if last push was less than one week ago', async () => {
-      const profile = createUserProfile(testUserId, {
-        lastPublicKeyPush: new Date(Date.now() - 3 * 24 * 60 * 60 * 1000),
-      });
-
-      await db.userProfile.add(profile);
-
-      await authService.ensurePublicKeyPublished(testPublicKeys, testUserId);
-
-      expect(mockMessageProtocol.postPublicKey).not.toHaveBeenCalled();
-    });
-
-    it('should publish if last push was more than one week ago', async () => {
-      const profile = createUserProfile(testUserId, {
-        lastPublicKeyPush: new Date(Date.now() - 8 * 24 * 60 * 60 * 1000),
-      });
-
-      await db.userProfile.add(profile);
-
-      vi.mocked(mockMessageProtocol.postPublicKey).mockResolvedValue('hash123');
-
-      await authService.ensurePublicKeyPublished(testPublicKeys, testUserId);
-
-      expect(mockMessageProtocol.postPublicKey).toHaveBeenCalledTimes(1);
-      const calledWith = vi.mocked(mockMessageProtocol.postPublicKey).mock
-        .calls[0][0];
-      expect(calledWith).toBe(encodeToBase64(testPublicKeys.to_bytes()));
-
-      const updatedProfile = await db.userProfile.get(testUserId);
-      expect(updatedProfile?.lastPublicKeyPush).toBeDefined();
-      expect(updatedProfile?.lastPublicKeyPush?.getTime()).toBeGreaterThan(
-        profile.lastPublicKeyPush!.getTime()
-      );
-    });
-
-    it('should publish if lastPublicKeyPush is undefined', async () => {
-      const profile = createUserProfile(testUserId);
-
-      await db.userProfile.add(profile);
-
-      vi.mocked(mockMessageProtocol.postPublicKey).mockResolvedValue('hash123');
-
-      await authService.ensurePublicKeyPublished(testPublicKeys, testUserId);
-
-      expect(mockMessageProtocol.postPublicKey).toHaveBeenCalledTimes(1);
-
-      const updatedProfile = await db.userProfile.get(testUserId);
-      expect(updatedProfile?.lastPublicKeyPush).toBeDefined();
-    });
-
-    it('should publish if last push was exactly one week ago', async () => {
-      const oneWeekAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
-      const profile = createUserProfile(testUserId, {
-        lastPublicKeyPush: oneWeekAgo,
-      });
-
-      await db.userProfile.add(profile);
-
-      vi.mocked(mockMessageProtocol.postPublicKey).mockResolvedValue('hash123');
-
-      await authService.ensurePublicKeyPublished(testPublicKeys, testUserId);
-
-      expect(mockMessageProtocol.postPublicKey).toHaveBeenCalledTimes(1);
-    });
-
-    it('should throw error if user profile not found', async () => {
-      await expect(
-        authService.ensurePublicKeyPublished(testPublicKeys, testUserId)
-      ).rejects.toThrow('User profile not found');
-
-      expect(mockMessageProtocol.postPublicKey).not.toHaveBeenCalled();
-    });
-
-    it('should encode public keys to base64 before posting', async () => {
-      const profile = createUserProfile(testUserId, {
-        lastPublicKeyPush: new Date(Date.now() - 8 * 24 * 60 * 60 * 1000),
-      });
-
-      await db.userProfile.add(profile);
-
-      vi.mocked(mockMessageProtocol.postPublicKey).mockResolvedValue('hash123');
-
-      await authService.ensurePublicKeyPublished(testPublicKeys, testUserId);
-
-      const calledWith = vi.mocked(mockMessageProtocol.postPublicKey).mock
-        .calls[0][0];
-      const decoded = decodeFromBase64(calledWith);
-      const originalBytes = testPublicKeys.to_bytes();
-
-      expect(Array.from(decoded)).toEqual(Array.from(originalBytes));
-    });
-  });
-});

package/test/services/discussion.spec.ts

@@ -1,279 +0,0 @@
-/**
- * DiscussionService tests
- *
- * Includes message status reset behavior for session renewal.
- */
-
-import { describe, it, expect, beforeEach } from 'vitest';
-import {
-  db,
-  MessageStatus,
-  MessageDirection,
-  MessageType,
-  DiscussionStatus,
-  DiscussionDirection,
-} from '../../src/db';
-import { encodeUserId } from '../../src/utils/userId';
-
-// ============================================================================
-// DiscussionService renew message reset behavior
-// ============================================================================
-
-const RENEW_OWNER_USER_ID = encodeUserId(new Uint8Array(32).fill(11));
-const RENEW_CONTACT_USER_ID = encodeUserId(new Uint8Array(32).fill(12));
-
-async function simulateRenewMessageReset(
-  ownerUserId: string,
-  contactUserId: string
-): Promise<number> {
-  return await db.messages
-    .where('[ownerUserId+contactUserId]')
-    .equals([ownerUserId, contactUserId])
-    .and(
-      message =>
-        message.direction === MessageDirection.OUTGOING &&
-        (message.status === MessageStatus.SENDING ||
-          message.status === MessageStatus.FAILED ||
-          message.status === MessageStatus.SENT)
-    )
-    .modify({
-      status: MessageStatus.WAITING_SESSION,
-      encryptedMessage: undefined,
-      seeker: undefined,
-    });
-}
-
-describe('DiscussionService renew message reset behavior', () => {
-  beforeEach(async () => {
-    if (!db.isOpen()) {
-      await db.open();
-    }
-    await Promise.all(db.tables.map(table => table.clear()));
-
-    await db.discussions.add({
-      ownerUserId: RENEW_OWNER_USER_ID,
-      contactUserId: RENEW_CONTACT_USER_ID,
-      direction: DiscussionDirection.INITIATED,
-      status: DiscussionStatus.ACTIVE,
-      unreadCount: 0,
-      createdAt: new Date(),
-      updatedAt: new Date(),
-    });
-  });
-
-  it('should reset SENT messages to WAITING_SESSION when renewing session', async () => {
-    const sentMessageId = await db.messages.add({
-      ownerUserId: RENEW_OWNER_USER_ID,
-      contactUserId: RENEW_CONTACT_USER_ID,
-      content: 'Already sent message',
-      type: MessageType.TEXT,
-      direction: MessageDirection.OUTGOING,
-      status: MessageStatus.SENT,
-      timestamp: new Date(),
-      seeker: new Uint8Array(32).fill(1),
-      encryptedMessage: new Uint8Array(64).fill(2),
-    });
-
-    await simulateRenewMessageReset(RENEW_OWNER_USER_ID, RENEW_CONTACT_USER_ID);
-
-    const sentMessage = await db.messages.get(sentMessageId);
-    expect(sentMessage?.status).toBe(MessageStatus.WAITING_SESSION);
-    expect(sentMessage?.seeker).toBeUndefined();
-    expect(sentMessage?.encryptedMessage).toBeUndefined();
-  });
-
-  it('should NOT reset DELIVERED messages when renewing session', async () => {
-    const deliveredMessageId = await db.messages.add({
-      ownerUserId: RENEW_OWNER_USER_ID,
-      contactUserId: RENEW_CONTACT_USER_ID,
-      content: 'Delivered message',
-      type: MessageType.TEXT,
-      direction: MessageDirection.OUTGOING,
-      status: MessageStatus.DELIVERED,
-      timestamp: new Date(),
-      seeker: new Uint8Array(32).fill(3),
-      encryptedMessage: new Uint8Array(64).fill(4),
-    });
-
-    await simulateRenewMessageReset(RENEW_OWNER_USER_ID, RENEW_CONTACT_USER_ID);
-
-    const deliveredMessage = await db.messages.get(deliveredMessageId);
-    expect(deliveredMessage?.status).toBe(MessageStatus.DELIVERED);
-    expect(deliveredMessage?.seeker).toBeDefined();
-    expect(deliveredMessage?.encryptedMessage).toBeDefined();
-  });
-
-  it('should NOT reset READ messages when renewing session', async () => {
-    const readMessageId = await db.messages.add({
-      ownerUserId: RENEW_OWNER_USER_ID,
-      contactUserId: RENEW_CONTACT_USER_ID,
-      content: 'Read message',
-      type: MessageType.TEXT,
-      direction: MessageDirection.OUTGOING,
-      status: MessageStatus.READ,
-      timestamp: new Date(),
-      seeker: new Uint8Array(32).fill(5),
-      encryptedMessage: new Uint8Array(64).fill(6),
-    });
-
-    await simulateRenewMessageReset(RENEW_OWNER_USER_ID, RENEW_CONTACT_USER_ID);
-
-    const readMessage = await db.messages.get(readMessageId);
-    expect(readMessage?.status).toBe(MessageStatus.READ);
-    expect(readMessage?.seeker).toBeDefined();
-  });
-
-  it('should reset SENDING messages to WAITING_SESSION when renewing', async () => {
-    const sendingMessageId = await db.messages.add({
-      ownerUserId: RENEW_OWNER_USER_ID,
-      contactUserId: RENEW_CONTACT_USER_ID,
-      content: 'Sending message',
-      type: MessageType.TEXT,
-      direction: MessageDirection.OUTGOING,
-      status: MessageStatus.SENDING,
-      timestamp: new Date(),
-      seeker: new Uint8Array(32).fill(5),
-      encryptedMessage: new Uint8Array(64).fill(6),
-    });
-
-    await simulateRenewMessageReset(RENEW_OWNER_USER_ID, RENEW_CONTACT_USER_ID);
-
-    const sendingMessage = await db.messages.get(sendingMessageId);
-    expect(sendingMessage?.status).toBe(MessageStatus.WAITING_SESSION);
-    expect(sendingMessage?.seeker).toBeUndefined();
-    expect(sendingMessage?.encryptedMessage).toBeUndefined();
-  });
-
-  it('should reset FAILED messages to WAITING_SESSION when renewing', async () => {
-    const failedMessageId = await db.messages.add({
-      ownerUserId: RENEW_OWNER_USER_ID,
-      contactUserId: RENEW_CONTACT_USER_ID,
-      content: 'Failed message',
-      type: MessageType.TEXT,
-      direction: MessageDirection.OUTGOING,
-      status: MessageStatus.FAILED,
-      timestamp: new Date(),
-      seeker: new Uint8Array(32).fill(7),
-      encryptedMessage: new Uint8Array(64).fill(8),
-    });
-
-    await simulateRenewMessageReset(RENEW_OWNER_USER_ID, RENEW_CONTACT_USER_ID);
-
-    const failedMessage = await db.messages.get(failedMessageId);
-    expect(failedMessage?.status).toBe(MessageStatus.WAITING_SESSION);
-    expect(failedMessage?.seeker).toBeUndefined();
-    expect(failedMessage?.encryptedMessage).toBeUndefined();
-  });
-
-  it('should keep WAITING_SESSION messages unchanged when renewing', async () => {
-    const waitingMessageId = await db.messages.add({
-      ownerUserId: RENEW_OWNER_USER_ID,
-      contactUserId: RENEW_CONTACT_USER_ID,
-      content: 'Waiting message',
-      type: MessageType.TEXT,
-      direction: MessageDirection.OUTGOING,
-      status: MessageStatus.WAITING_SESSION,
-      timestamp: new Date(),
-    });
-
-    await simulateRenewMessageReset(RENEW_OWNER_USER_ID, RENEW_CONTACT_USER_ID);
-
-    const waitingMessage = await db.messages.get(waitingMessageId);
-    expect(waitingMessage?.status).toBe(MessageStatus.WAITING_SESSION);
-  });
-
-  it('should handle mixed message statuses correctly on renew', async () => {
-    const sentId = await db.messages.add({
-      ownerUserId: RENEW_OWNER_USER_ID,
-      contactUserId: RENEW_CONTACT_USER_ID,
-      content: 'Sent',
-      type: MessageType.TEXT,
-      direction: MessageDirection.OUTGOING,
-      status: MessageStatus.SENT,
-      timestamp: new Date(),
-      seeker: new Uint8Array(32).fill(1),
-      encryptedMessage: new Uint8Array(64).fill(1),
-    });
-
-    const sendingId = await db.messages.add({
-      ownerUserId: RENEW_OWNER_USER_ID,
-      contactUserId: RENEW_CONTACT_USER_ID,
-      content: 'Sending',
-      type: MessageType.TEXT,
-      direction: MessageDirection.OUTGOING,
-      status: MessageStatus.SENDING,
-      timestamp: new Date(),
-      seeker: new Uint8Array(32).fill(2),
-      encryptedMessage: new Uint8Array(64).fill(2),
-    });
-
-    const failedId = await db.messages.add({
-      ownerUserId: RENEW_OWNER_USER_ID,
-      contactUserId: RENEW_CONTACT_USER_ID,
-      content: 'Failed',
-      type: MessageType.TEXT,
-      direction: MessageDirection.OUTGOING,
-      status: MessageStatus.FAILED,
-      timestamp: new Date(),
-    });
-
-    const deliveredId = await db.messages.add({
-      ownerUserId: RENEW_OWNER_USER_ID,
-      contactUserId: RENEW_CONTACT_USER_ID,
-      content: 'Delivered',
-      type: MessageType.TEXT,
-      direction: MessageDirection.OUTGOING,
-      status: MessageStatus.DELIVERED,
-      timestamp: new Date(),
-      seeker: new Uint8Array(32).fill(3),
-      encryptedMessage: new Uint8Array(64).fill(3),
-    });
-
-    const waitingId = await db.messages.add({
-      ownerUserId: RENEW_OWNER_USER_ID,
-      contactUserId: RENEW_CONTACT_USER_ID,
-      content: 'Waiting',
-      type: MessageType.TEXT,
-      direction: MessageDirection.OUTGOING,
-      status: MessageStatus.WAITING_SESSION,
-      timestamp: new Date(),
-    });
-
-    await simulateRenewMessageReset(RENEW_OWNER_USER_ID, RENEW_CONTACT_USER_ID);
-
-    const sent = await db.messages.get(sentId);
-    expect(sent?.status).toBe(MessageStatus.WAITING_SESSION);
-    expect(sent?.seeker).toBeUndefined();
-
-    const sending = await db.messages.get(sendingId);
-    expect(sending?.status).toBe(MessageStatus.WAITING_SESSION);
-    expect(sending?.seeker).toBeUndefined();
-
-    const failed = await db.messages.get(failedId);
-    expect(failed?.status).toBe(MessageStatus.WAITING_SESSION);
-
-    const delivered = await db.messages.get(deliveredId);
-    expect(delivered?.status).toBe(MessageStatus.DELIVERED);
-    expect(delivered?.seeker).toBeDefined();
-
-    const waiting = await db.messages.get(waitingId);
-    expect(waiting?.status).toBe(MessageStatus.WAITING_SESSION);
-  });
-
-  it('should NOT reset incoming messages when renewing', async () => {
-    const incomingId = await db.messages.add({
-      ownerUserId: RENEW_OWNER_USER_ID,
-      contactUserId: RENEW_CONTACT_USER_ID,
-      content: 'Incoming message',
-      type: MessageType.TEXT,
-      direction: MessageDirection.INCOMING,
-      status: MessageStatus.DELIVERED,
-      timestamp: new Date(),
-    });
-
-    await simulateRenewMessageReset(RENEW_OWNER_USER_ID, RENEW_CONTACT_USER_ID);
-
-    const incoming = await db.messages.get(incomingId);
-    expect(incoming?.status).toBe(MessageStatus.DELIVERED);
-  });
-});