Skip to content

High performance self-hosted photo and video management solution.

3.3 KB
Raw Blame
import { Writable } from 'node:stream';
import { SyncEntityType } from 'src/enum.js';
import { send } from 'src/services/sync.service.js';
import { ClientDisconnectedError } from 'src/utils/response.js';
import { serialize } from 'src/utils/sync.js';

type TestStream = {
  stream: Writable;
  chunks: string[];
  flushNext: () => void;
  pendingCount: () => number;
};

const createTestStream = (highWaterMark: number): TestStream => {
  const chunks: string[] = [];
  const pendingCallbacks: Array<() => void> = [];

  const stream = new Writable({
    highWaterMark,
    write(chunk, _encoding, callback) {
      chunks.push(chunk.toString());
      pendingCallbacks.push(callback);
    },
  });

  return {
    stream,
    chunks,
    flushNext: () => pendingCallbacks.shift()?.(),
    pendingCount: () => pendingCallbacks.length,
  };
};

describe('send', () => {
  const item = {
    type: SyncEntityType.SyncCompleteV1 as const,
    data: {},
    ids: ['now-id'] as [string],
  };

  it('should resolve immediately when the stream has capacity', async () => {
    // A large highWaterMark means write() never signals backpressure for a
    // single small item.
    const { stream, chunks, flushNext } = createTestStream(1024 * 1024);

    const sendPromise = send(stream, item);
    flushNext();
    await sendPromise;

    expect(chunks).toEqual([serialize(item)]);
  });

  it('should wait for the drain event when the stream signals backpressure', async () => {
    // A tiny highWaterMark means the very first write already exceeds
    // capacity, so write() returns false and send() must wait for 'drain'.
    const { stream, chunks, flushNext, pendingCount } = createTestStream(1);

    let resolved = false;
    const sendPromise = send(stream, item).then(() => {
      resolved = true;
    });

    // Let any pending microtasks run; send() should still be waiting on the
    // underlying write to complete and 'drain' to fire — it must not resolve
    // just because write() was called.
    await Promise.resolve();
    await Promise.resolve();
    expect(resolved).toBe(false);
    expect(pendingCount()).toBe(1);

    // Completing the write lets the stream's internal buffer drop back below
    // highWaterMark, which is what triggers the 'drain' event.
    flushNext();
    await sendPromise;

    expect(resolved).toBe(true);
    expect(chunks).toEqual([serialize(item)]);
  });

  it('should throw a disconnect error when the stream destroyed', async () => {
    const { stream, chunks } = createTestStream(1024 * 1024);

    stream.destroy();

    await expect(send(stream, item)).rejects.toBeInstanceOf(ClientDisconnectedError);
    expect(chunks).toEqual([]);
  });

  it('should throw a disconnect error when the stream is destroyed after writing some data', async () => {
    const { stream } = createTestStream(1);

    const sendPromise = send(stream, item);

    await Promise.resolve();
    stream.destroy();

    await expect(sendPromise).rejects.toBeInstanceOf(ClientDisconnectedError);
  });

  it('should handle a stream error', async () => {
    const { stream } = createTestStream(1);
    const error = new Error('socket hang up');

    const sendPromise = send(stream, item);

    await Promise.resolve();
    stream.emit('error', error);

    await expect(sendPromise).rejects.toBe(error);
  });
});