Skip to content

The OSINT investigator's workbench. One case, one folder, every tool. Local-first: your media and your investigations never leave your machine.

JavaScript
7.2 KB
Raw Blame
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { createAutosave } from './autosave.svelte.js';

/** A write the test finishes by hand, to hold one in flight. */
function deferred() {
  let resolve;
  let reject;
  const promise = new Promise((res, rej) => {
    resolve = res;
    reject = rej;
  });
  return { promise, resolve, reject };
}

beforeEach(() => vi.useFakeTimers());
afterEach(() => vi.useRealTimers());

describe('createAutosave', () => {
  it('writes once, after the changes stop', async () => {
    const write = vi.fn(async () => {});
    const saver = createAutosave({ write, delay: 500 });

    saver.schedule();
    await vi.advanceTimersByTimeAsync(300);
    saver.schedule();
    await vi.advanceTimersByTimeAsync(300);
    expect(write).not.toHaveBeenCalled();
    expect(saver.state.status).toBe('pending');

    await vi.advanceTimersByTimeAsync(250);
    expect(write).toHaveBeenCalledTimes(1);
    expect(saver.state.status).toBe('saved');
  });

  it('never runs two writes at once, and writes a change made during one right after', async () => {
    const first = deferred();
    const write = vi.fn().mockReturnValueOnce(first.promise).mockResolvedValue();
    const saver = createAutosave({ write, delay: 100 });

    saver.schedule();
    await vi.advanceTimersByTimeAsync(100);
    expect(saver.state.status).toBe('saving');
    saver.schedule();
    await vi.advanceTimersByTimeAsync(100);
    expect(write).toHaveBeenCalledTimes(1);

    first.resolve();
    await vi.advanceTimersByTimeAsync(0);
    expect(write).toHaveBeenCalledTimes(2);
  });

  it('writes what is pending on flush, without waiting out the delay', async () => {
    const write = vi.fn(async () => {});
    const saver = createAutosave({ write, delay: 10_000 });

    saver.schedule();
    await saver.flush();

    expect(write).toHaveBeenCalledTimes(1);
    expect(saver.pending).toBe(false);
  });

  it('waits for a write in flight on flush', async () => {
    const running = deferred();
    const write = vi.fn(() => running.promise);
    const saver = createAutosave({ write, delay: 10 });
    saver.schedule();
    await vi.advanceTimersByTimeAsync(10);

    let flushed = false;
    saver.flush().then(() => (flushed = true));
    await vi.advanceTimersByTimeAsync(0);
    expect(flushed).toBe(false);

    running.resolve();
    await vi.advanceTimersByTimeAsync(0);
    expect(flushed).toBe(true);
    expect(write).toHaveBeenCalledTimes(1);
  });

  describe('a change made while a write is in flight', () => {
    /** Two writes the test ends by hand, logging when each starts and ends. */
    function twoWrites() {
      const log = [];
      const writes = [deferred(), deferred()];
      let n = 0;
      const write = vi.fn(() => {
        const i = n++;
        log.push(`start ${i + 1}`);
        return writes[i].promise.then(() => log.push(`end ${i + 1}`));
      });
      return { log, writes, write };
    }

    async function flushAfterBothWrites(saver, { log, writes }) {
      saver.flush().then(() => log.push('flushed'));
      writes[0].resolve();
      await vi.advanceTimersByTimeAsync(0);
      expect(log).toEqual(['start 1', 'end 1', 'start 2']);
      writes[1].resolve();
      await vi.advanceTimersByTimeAsync(0);
      expect(log).toEqual(['start 1', 'end 1', 'start 2', 'end 2', 'flushed']);
      expect(saver.pending).toBe(false);
    }

    it('is waited for by flush while its timer is still counting', async () => {
      const writes = twoWrites();
      const saver = createAutosave({ write: writes.write, delay: 100 });
      saver.schedule();
      await vi.advanceTimersByTimeAsync(100);
      saver.schedule(); // the timer is pending, the first write still running

      await flushAfterBothWrites(saver, writes);
    });

    it('is waited for by flush once it is queued behind the write', async () => {
      const writes = twoWrites();
      const saver = createAutosave({ write: writes.write, delay: 100 });
      saver.schedule();
      await vi.advanceTimersByTimeAsync(100);
      saver.schedule();
      await vi.advanceTimersByTimeAsync(100); // the timer fired into the running write

      await flushAfterBothWrites(saver, writes);
    });

    it('leaves the status of that second write when flush returns', async () => {
      const first = deferred();
      const second = deferred();
      const write = vi.fn().mockReturnValueOnce(first.promise).mockReturnValueOnce(second.promise);
      const saver = createAutosave({ write, delay: 100 });
      saver.schedule();
      await vi.advanceTimersByTimeAsync(100);
      saver.schedule();

      let seen = null;
      saver.flush().then(() => (seen = { ...saver.state }));
      first.resolve();
      setTimeout(() => second.reject(new Error('gone')), 50);
      await vi.advanceTimersByTimeAsync(50);
      expect(write).toHaveBeenCalledTimes(2);
      expect(seen).toEqual({ status: 'error', error: 'gone' });
    });
  });

  it('keeps saving after a write that throws before it returns a promise', async () => {
    const write = vi.fn(() => {
      throw new Error('bad state');
    });
    const saver = createAutosave({ write, delay: 10 });
    saver.schedule();
    await saver.flush();
    expect(saver.state.status).toBe('error');
    expect(saver.unsaved).toBe(true); // failed, not stuck: the next write goes out

    write.mockResolvedValue();
    saver.schedule();
    await saver.flush();
    expect(saver.state.status).toBe('saved');
  });

  it('says a failed write failed, and tries again when asked', async () => {
    const write = vi.fn().mockRejectedValueOnce(new Error('disk full')).mockResolvedValue();
    const saver = createAutosave({ write, delay: 10 });

    saver.schedule();
    await vi.advanceTimersByTimeAsync(10);
    expect(saver.state.status).toBe('error');
    expect(saver.state.error).toBe('disk full');

    saver.schedule();
    await saver.flush();
    expect(saver.state.status).toBe('saved');
    expect(saver.state.error).toBe('');
  });

  it('retries a failed write when flushed alone, which is what Retry does', async () => {
    const write = vi.fn().mockRejectedValueOnce(new Error('disk full')).mockResolvedValue();
    const saver = createAutosave({ write, delay: 10 });

    saver.schedule();
    await vi.advanceTimersByTimeAsync(10);
    expect(saver.unsaved).toBe(true);
    expect(saver.pending).toBe(true); // a page closing now still has something to send

    await saver.flush();
    expect(write).toHaveBeenCalledTimes(2);
    expect(saver.state.status).toBe('saved');
    expect(saver.unsaved).toBe(false);
  });

  it('stays unsaved when the retry fails too, so the tool can refuse to let go', async () => {
    const write = vi.fn().mockRejectedValue(new Error('too large'));
    const saver = createAutosave({ write, delay: 10 });
    saver.schedule();
    await saver.flush();
    await saver.flush();
    expect(write).toHaveBeenCalledTimes(2);
    expect(saver.unsaved).toBe(true);
  });

  it('forgets a pending write for a document being thrown away', async () => {
    const write = vi.fn(async () => {});
    const saver = createAutosave({ write, delay: 50 });

    saver.schedule();
    saver.cancel();
    await vi.advanceTimersByTimeAsync(100);
    await saver.flush();

    expect(write).not.toHaveBeenCalled();
    expect(saver.state.status).toBe('idle');
  });
});