@massalabs/gossip-sdk 0.0.2-dev.20260128094509

package/test/integration/sdk-lifecycle.spec.ts

@@ -0,0 +1,325 @@
+/**
+ * GossipSdk lifecycle and event wiring tests
+ */
+
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { GossipDatabase } from '../../src/db';
+import type { EncryptionKey } from '../../src/wasm/encryption';
+
+const protocolMock = vi.hoisted(() => ({
+  createMessageProtocolMock: vi.fn(),
+}));
+
+const eventState = vi.hoisted(() => ({
+  lastEvents: null as {
+    onMessageReceived?: (message: unknown) => void;
+    onDiscussionRequest?: (...args: unknown[]) => void;
+    onError?: (...args: unknown[]) => void;
+  } | null,
+}));
+
+const sessionMock = vi.hoisted(() => {
+  const userIdBytes = new Uint8Array(32).fill(9);
+  const userIdEncoded = 'gossip1testsessionuserid';
+  const state = { lastSessionInstance: null as MockSession | null };
+
+  class MockSession {
+    userId = userIdBytes;
+    userIdEncoded = userIdEncoded;
+    ourPk = { key: 'pk' };
+    load = vi.fn();
+    cleanup = vi.fn();
+    toEncryptedBlob = vi.fn().mockReturnValue(new Uint8Array([9]));
+    private onPersist?: () => void;
+
+    constructor(_keys: unknown, onPersist?: () => void) {
+      this.onPersist = onPersist;
+      state.lastSessionInstance = this;
+    }
+
+    emitPersist() {
+      this.onPersist?.();
+    }
+  }
+
+  return { MockSession, state, userIdBytes, userIdEncoded };
+});
+
+vi.mock('../../src/api/messageProtocol', () => ({
+  createMessageProtocol: () => protocolMock.createMessageProtocolMock(),
+}));
+
+vi.mock('../../src/wasm/loader', () => ({
+  startWasmInitialization: vi.fn(),
+  ensureWasmInitialized: vi.fn().mockResolvedValue(undefined),
+}));
+
+vi.mock('../../src/wasm/userKeys', () => ({
+  generateUserKeys: vi.fn().mockResolvedValue({}),
+}));
+
+vi.mock('../../src/wasm/session', async () => {
+  return {
+    SessionModule: sessionMock.MockSession,
+  };
+});
+
+vi.mock('../../src/services/auth', () => ({
+  AuthService: class {
+    constructor() {}
+  },
+}));
+
+vi.mock('../../src/services/announcement', () => ({
+  AnnouncementService: class {
+    constructor(
+      _db: unknown,
+      _protocol: unknown,
+      _session: unknown,
+      events: typeof eventState.lastEvents
+    ) {
+      eventState.lastEvents = events ?? null;
+    }
+  },
+}));
+
+vi.mock('../../src/services/message', () => ({
+  MessageService: class {
+    sendMessage = vi.fn();
+    fetchMessages = vi.fn();
+    resendMessages = vi.fn();
+    findMessageBySeeker = vi.fn();
+
+    constructor(
+      _db: unknown,
+      _protocol: unknown,
+      _session: unknown,
+      events: typeof eventState.lastEvents
+    ) {
+      eventState.lastEvents = events ?? null;
+    }
+  },
+}));
+
+vi.mock('../../src/services/discussion', () => ({
+  DiscussionService: class {
+    initialize = vi.fn();
+    accept = vi.fn();
+    renew = vi.fn();
+    isStableState = vi.fn();
+    constructor(
+      _db: unknown,
+      _announcement: unknown,
+      _session: unknown,
+      events: typeof eventState.lastEvents
+    ) {
+      eventState.lastEvents = events ?? null;
+    }
+  },
+}));
+
+vi.mock('../../src/services/refresh', () => ({
+  RefreshService: class {
+    handleSessionRefresh = vi.fn();
+    constructor(
+      _db: unknown,
+      _message: unknown,
+      _session: unknown,
+      events: typeof eventState.lastEvents
+    ) {
+      eventState.lastEvents = events ?? null;
+    }
+  },
+}));
+
+describe('GossipSdkImpl lifecycle', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    protocolMock.createMessageProtocolMock.mockReturnValue({
+      fetchMessages: vi.fn(),
+      sendMessage: vi.fn(),
+      sendAnnouncement: vi.fn(),
+      fetchAnnouncements: vi.fn(),
+      fetchPublicKeyByUserId: vi.fn(),
+      postPublicKey: vi.fn(),
+      changeNode: vi.fn(),
+    });
+    sessionMock.state.lastSessionInstance = null;
+    eventState.lastEvents = null;
+  });
+
+  it('initializes once and exposes auth service', async () => {
+    const { GossipSdkImpl } = await import('../../src/gossipSdk');
+    const sdk = new GossipSdkImpl();
+
+    await sdk.init({ db: new GossipDatabase() });
+    expect(sdk.isInitialized).toBe(true);
+    expect(() => sdk.auth).not.toThrow();
+
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    await sdk.init({ db: new GossipDatabase() });
+    expect(warnSpy).toHaveBeenCalled();
+  });
+
+  it('throws on openSession before init', async () => {
+    const { GossipSdkImpl } = await import('../../src/gossipSdk');
+    const sdk = new GossipSdkImpl();
+
+    await expect(sdk.openSession({ mnemonic: 'test words' })).rejects.toThrow(
+      'SDK not initialized'
+    );
+  });
+
+  it('opens and closes session with getters wired', async () => {
+    const { GossipSdkImpl } = await import('../../src/gossipSdk');
+    const sdk = new GossipSdkImpl();
+
+    await sdk.init({ db: new GossipDatabase() });
+    await sdk.openSession({ mnemonic: 'test words' });
+
+    expect(sdk.isSessionOpen).toBe(true);
+    expect(sdk.userIdBytes).toBeInstanceOf(Uint8Array);
+    expect(sdk.userIdBytes.length).toBe(32);
+    expect(sdk.publicKeys).toBeDefined();
+
+    await sdk.closeSession();
+    expect(sdk.isSessionOpen).toBe(false);
+    expect(sessionMock.state.lastSessionInstance?.cleanup).toHaveBeenCalled();
+    expect(() => sdk.messages).toThrow('No session open');
+  });
+
+  it('restores encrypted session when provided', async () => {
+    const { GossipSdkImpl } = await import('../../src/gossipSdk');
+    const sdk = new GossipSdkImpl();
+    const encryptedSession = new Uint8Array([1, 2, 3]);
+    const encryptionKey = {} as EncryptionKey;
+
+    await sdk.init({ db: new GossipDatabase() });
+    await sdk.openSession({
+      mnemonic: 'test words',
+      encryptedSession,
+      encryptionKey,
+    });
+
+    expect(sessionMock.state.lastSessionInstance?.load).toHaveBeenCalled();
+  });
+
+  it('persists session via onPersist callback', async () => {
+    const { GossipSdkImpl } = await import('../../src/gossipSdk');
+    const sdk = new GossipSdkImpl();
+    const onPersist = vi.fn().mockResolvedValue(undefined);
+    const persistEncryptionKey = {} as EncryptionKey;
+
+    await sdk.init({ db: new GossipDatabase() });
+    await sdk.openSession({
+      mnemonic: 'test words',
+      onPersist,
+      persistEncryptionKey,
+    });
+
+    sessionMock.state.lastSessionInstance?.emitPersist();
+    expect(onPersist).toHaveBeenCalledWith(
+      new Uint8Array([9]),
+      persistEncryptionKey
+    );
+  });
+
+  it('bridges message events to sdk.on handlers', async () => {
+    const { GossipSdkImpl } = await import('../../src/gossipSdk');
+    const sdk = new GossipSdkImpl();
+    const handler = vi.fn();
+
+    await sdk.init({ db: new GossipDatabase() });
+    sdk.on('message', handler);
+    await sdk.openSession({ mnemonic: 'test words' });
+
+    eventState.lastEvents?.onMessageReceived?.({ id: 1 });
+    expect(handler).toHaveBeenCalledWith({ id: 1 });
+  });
+});
+
+describe('GossipSdkImpl.configurePersistence', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    protocolMock.createMessageProtocolMock.mockReturnValue({
+      fetchMessages: vi.fn(),
+      sendMessage: vi.fn(),
+      sendAnnouncement: vi.fn(),
+      fetchAnnouncements: vi.fn(),
+      fetchPublicKeyByUserId: vi.fn(),
+      postPublicKey: vi.fn(),
+      changeNode: vi.fn(),
+    });
+    sessionMock.state.lastSessionInstance = null;
+    eventState.lastEvents = null;
+  });
+
+  it('throws if called before session is opened', async () => {
+    const { GossipSdkImpl } = await import('../../src/gossipSdk');
+    const sdk = new GossipSdkImpl();
+    const onPersist = vi.fn();
+    const encryptionKey = {} as EncryptionKey;
+
+    await sdk.init({ db: new GossipDatabase() });
+
+    expect(() => sdk.configurePersistence(encryptionKey, onPersist)).toThrow(
+      'No session open'
+    );
+  });
+
+  it('configures persistence after session is opened without initial onPersist', async () => {
+    const { GossipSdkImpl } = await import('../../src/gossipSdk');
+    const sdk = new GossipSdkImpl();
+    const onPersist = vi.fn().mockResolvedValue(undefined);
+    const encryptionKey = {} as EncryptionKey;
+
+    await sdk.init({ db: new GossipDatabase() });
+
+    await sdk.openSession({ mnemonic: 'test words' });
+
+    sdk.configurePersistence(encryptionKey, onPersist);
+
+    sessionMock.state.lastSessionInstance?.emitPersist();
+
+    expect(onPersist).toHaveBeenCalledWith(new Uint8Array([9]), encryptionKey);
+  });
+
+  it('replaces existing onPersist callback when reconfigured', async () => {
+    const { GossipSdkImpl } = await import('../../src/gossipSdk');
+    const sdk = new GossipSdkImpl();
+    const originalOnPersist = vi.fn().mockResolvedValue(undefined);
+    const newOnPersist = vi.fn().mockResolvedValue(undefined);
+    const originalKey = { original: true } as unknown as EncryptionKey;
+    const newKey = { new: true } as unknown as EncryptionKey;
+
+    await sdk.init({ db: new GossipDatabase() });
+
+    await sdk.openSession({
+      mnemonic: 'test words',
+      onPersist: originalOnPersist,
+      persistEncryptionKey: originalKey,
+    });
+
+    sdk.configurePersistence(newKey, newOnPersist);
+
+    sessionMock.state.lastSessionInstance?.emitPersist();
+
+    expect(originalOnPersist).not.toHaveBeenCalled();
+    expect(newOnPersist).toHaveBeenCalledWith(new Uint8Array([9]), newKey);
+  });
+
+  it('ensures persistence is called with correct encryption key', async () => {
+    const { GossipSdkImpl } = await import('../../src/gossipSdk');
+    const sdk = new GossipSdkImpl();
+    const onPersist = vi.fn().mockResolvedValue(undefined);
+    const specificKey = { keyId: 'test-key-123' } as unknown as EncryptionKey;
+
+    await sdk.init({ db: new GossipDatabase() });
+    await sdk.openSession({ mnemonic: 'test words' });
+
+    sdk.configurePersistence(specificKey, onPersist);
+    sessionMock.state.lastSessionInstance?.emitPersist();
+
+    expect(onPersist).toHaveBeenCalledWith(expect.any(Uint8Array), specificKey);
+  });
+});

package/test/mocks/index.ts

@@ -0,0 +1,9 @@
+/**
+ * Test Mocks
+ *
+ * Only MockMessageProtocol is needed - it provides an in-memory
+ * implementation to avoid network calls during tests.
+ *
+ * SessionModule uses real WASM - no mock needed since WASM works in Node.
+ */
+export { MockMessageProtocol } from './mockMessageProtocol';

package/test/mocks/mockMessageProtocol.ts

@@ -0,0 +1,100 @@
+/**
+ * In-Memory Mock Message Protocol for Testing
+ *
+ * This mock stores messages and announcements in memory,
+ * allowing tests to verify messaging flows without network calls.
+ */
+
+import type { IMessageProtocol } from '../../src/api/messageProtocol/types';
+import type {
+  EncryptedMessage,
+  BulletinItem,
+} from '../../src/api/messageProtocol/types';
+
+export class MockMessageProtocol implements IMessageProtocol {
+  private messages: Map<string, Uint8Array> = new Map();
+  private announcements: BulletinItem[] = [];
+  private announcementCounter = 0;
+
+  constructor(
+    public baseUrl: string = 'mock://test',
+    public timeout: number = 10000,
+    public retryAttempts: number = 3
+  ) {}
+
+  async fetchMessages(seekers: Uint8Array[]): Promise<EncryptedMessage[]> {
+    const results: EncryptedMessage[] = [];
+    for (const seeker of seekers) {
+      const key = this.uint8ArrayToKey(seeker);
+      const ciphertext = this.messages.get(key);
+      if (ciphertext) {
+        results.push({ seeker, ciphertext });
+      }
+    }
+    return results;
+  }
+
+  async sendMessage(message: EncryptedMessage): Promise<void> {
+    const key = this.uint8ArrayToKey(message.seeker);
+    this.messages.set(key, message.ciphertext);
+  }
+
+  async sendAnnouncement(announcement: Uint8Array): Promise<string> {
+    const counter = String(++this.announcementCounter);
+    this.announcements.push({ counter, data: announcement });
+    return counter;
+  }
+
+  async fetchAnnouncements(
+    limit?: number,
+    cursor?: string
+  ): Promise<BulletinItem[]> {
+    let results = [...this.announcements];
+
+    // Filter by cursor (return only announcements after this counter)
+    if (cursor) {
+      const cursorNum = parseInt(cursor, 10);
+      results = results.filter(a => parseInt(a.counter, 10) > cursorNum);
+    }
+
+    // Apply limit
+    if (limit && limit > 0) {
+      results = results.slice(0, limit);
+    }
+
+    return results;
+  }
+
+  async fetchPublicKeyByUserId(_userId: Uint8Array): Promise<string> {
+    // Return empty string - tests should handle this
+    return '';
+  }
+
+  async postPublicKey(_publicKey: string): Promise<string> {
+    return 'mock-counter';
+  }
+
+  async changeNode(newBaseUrl: string): Promise<{ success: boolean }> {
+    this.baseUrl = newBaseUrl;
+    return { success: true };
+  }
+
+  // Test helper methods
+  clearMockData(): void {
+    this.messages.clear();
+    this.announcements = [];
+    this.announcementCounter = 0;
+  }
+
+  getStoredMessages(): Map<string, Uint8Array> {
+    return new Map(this.messages);
+  }
+
+  getStoredAnnouncements(): BulletinItem[] {
+    return [...this.announcements];
+  }
+
+  private uint8ArrayToKey(arr: Uint8Array): string {
+    return Array.from(arr).join(',');
+  }
+}