@accounter/scraper-app 0.0.1

package/src/server/__tests__/otp-manager.test.ts

@@ -0,0 +1,132 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { OtpCancelledError, OtpManager, OtpTimeoutError } from '../otp-manager.js';
+import type { ServerMessage } from '../../shared/ws-protocol.js';
+
+function makeEmit() {
+  const sent: ServerMessage[] = [];
+  const emit = (msg: ServerMessage) => sent.push(msg);
+  return { emit, sent };
+}
+
+afterEach(() => {
+  vi.useRealTimers();
+});
+
+describe('waitForOtp', () => {
+  it('resolves with the correct string when submitOtp is called', async () => {
+    const manager = new OtpManager();
+    const { emit } = makeEmit();
+    const promise = manager.waitForOtp('src-1', emit);
+    manager.submitOtp('src-1', '123456');
+    await expect(promise).resolves.toBe('123456');
+  });
+
+  it('rejects with OtpTimeoutError after timeout elapses', async () => {
+    vi.useFakeTimers();
+    const manager = new OtpManager();
+    const { emit } = makeEmit();
+    const promise = manager.waitForOtp('src-1', emit, 100);
+    vi.advanceTimersByTime(100);
+    await expect(promise).rejects.toBeInstanceOf(OtpTimeoutError);
+  });
+
+  it('emits otp-required immediately on call', async () => {
+    const manager = new OtpManager();
+    const { emit, sent } = makeEmit();
+    const promise = manager.waitForOtp('src-1', emit);
+    expect(sent).toEqual([{ type: 'otp-required', sourceId: 'src-1' }]);
+    manager.submitOtp('src-1', 'x');
+    await promise;
+  });
+
+  it('OtpTimeoutError carries the sourceId', async () => {
+    vi.useFakeTimers();
+    const manager = new OtpManager();
+    const { emit } = makeEmit();
+    const promise = manager.waitForOtp('src-timeout', emit, 100);
+    vi.advanceTimersByTime(100);
+    try {
+      await promise;
+    } catch (e) {
+      expect(e).toBeInstanceOf(OtpTimeoutError);
+      expect((e as OtpTimeoutError).sourceId).toBe('src-timeout');
+    }
+  });
+});
+
+describe('submitOtp', () => {
+  it('is a no-op for an unknown sourceId', () => {
+    const manager = new OtpManager();
+    expect(() => manager.submitOtp('does-not-exist', '000000')).not.toThrow();
+  });
+
+  it('clears the pending entry so a second submit is a no-op', async () => {
+    const manager = new OtpManager();
+    const { emit } = makeEmit();
+    const promise = manager.waitForOtp('src-1', emit);
+    manager.submitOtp('src-1', 'first');
+    manager.submitOtp('src-1', 'second'); // should not throw or double-resolve
+    await expect(promise).resolves.toBe('first');
+  });
+});
+
+describe('cancelOtp', () => {
+  it('rejects the waiting promise with OtpCancelledError', async () => {
+    const manager = new OtpManager();
+    const { emit } = makeEmit();
+    const promise = manager.waitForOtp('src-1', emit);
+    manager.cancelOtp('src-1');
+    await expect(promise).rejects.toBeInstanceOf(OtpCancelledError);
+  });
+
+  it('is a no-op for an unknown sourceId', () => {
+    const manager = new OtpManager();
+    expect(() => manager.cancelOtp('does-not-exist')).not.toThrow();
+  });
+});
+
+describe('hasPendingOtp', () => {
+  it('returns true while waiting, false after resolution', async () => {
+    const manager = new OtpManager();
+    const { emit } = makeEmit();
+    const promise = manager.waitForOtp('src-1', emit);
+    expect(manager.hasPendingOtp('src-1')).toBe(true);
+    manager.submitOtp('src-1', 'otp');
+    await promise;
+    expect(manager.hasPendingOtp('src-1')).toBe(false);
+  });
+
+  it('returns false for an unknown sourceId', () => {
+    const manager = new OtpManager();
+    expect(manager.hasPendingOtp('nope')).toBe(false);
+  });
+});
+
+describe('concurrent waitForOtp for different sourceIds', () => {
+  it('resolves each independently', async () => {
+    const manager = new OtpManager();
+    const { emit } = makeEmit();
+    const p1 = manager.waitForOtp('src-a', emit);
+    const p2 = manager.waitForOtp('src-b', emit);
+
+    manager.submitOtp('src-a', 'otp-for-a');
+    await expect(p1).resolves.toBe('otp-for-a');
+
+    manager.submitOtp('src-b', 'otp-for-b');
+    await expect(p2).resolves.toBe('otp-for-b');
+  });
+
+  it('timing out one does not affect the other', async () => {
+    vi.useFakeTimers();
+    const manager = new OtpManager();
+    const { emit } = makeEmit();
+    const p1 = manager.waitForOtp('src-short', emit, 100);
+    const p2 = manager.waitForOtp('src-long', emit, 10_000);
+
+    vi.advanceTimersByTime(100);
+    await expect(p1).rejects.toBeInstanceOf(OtpTimeoutError);
+
+    manager.submitOtp('src-long', 'still-good');
+    await expect(p2).resolves.toBe('still-good');
+  });
+});

package/src/server/__tests__/scrape-runner.test.ts

@@ -0,0 +1,144 @@
+import { afterEach, describe, expect, it } from 'vitest';
+import { _resetRunState, startRun, type ScrapeTask } from '../scrape-runner.js';
+import type { ServerMessage } from '../../shared/ws-protocol.js';
+
+type TaskResult = { inserted: number; skipped: number; insertedIds: string[]; insertedTransactions: []; changedTransactions: [] };
+
+function makeTask(
+  sourceId: string,
+  run: () => Promise<TaskResult> = async () => ({
+    inserted: 2,
+    skipped: 1,
+    insertedIds: ['id-1', 'id-2'],
+    insertedTransactions: [],
+    changedTransactions: [],
+  }),
+): ScrapeTask {
+  return { sourceId, nickname: sourceId, type: 'poalim', run };
+}
+
+afterEach(() => {
+  _resetRunState();
+});
+
+// ── Sequential ────────────────────────────────────────────────────────────────
+
+describe('sequential mode', () => {
+  it('emits pending×2 → running→done task1 → running→done task2 → run-complete', async () => {
+    const events: ServerMessage[] = [];
+    const emit = (msg: ServerMessage) => events.push(msg);
+
+    await startRun([makeTask('src-1'), makeTask('src-2')], false, emit);
+
+    expect(events[0]).toEqual({ type: 'task-pending', sourceId: 'src-1' });
+    expect(events[1]).toEqual({ type: 'task-pending', sourceId: 'src-2' });
+    expect(events[2]).toMatchObject({ type: 'task-running', sourceId: 'src-1' });
+    expect(events[3]).toMatchObject({ type: 'task-done', sourceId: 'src-1', inserted: 2, skipped: 1 });
+    expect(events[4]).toMatchObject({ type: 'task-running', sourceId: 'src-2' });
+    expect(events[5]).toMatchObject({ type: 'task-done', sourceId: 'src-2', inserted: 2, skipped: 1 });
+    expect(events[6]).toEqual({ type: 'run-complete', totalInserted: 4, totalSkipped: 2, errors: 0 });
+    expect(events).toHaveLength(7);
+  });
+
+  it('returns a RunRecord with correct totals and timestamps', async () => {
+    const before = new Date();
+    const record = await startRun([makeTask('src-1')], false, () => {});
+    const after = new Date();
+
+    expect(record.id).toMatch(/^[\da-f-]{36}$/);
+    expect(record.totalInserted).toBe(2);
+    expect(record.totalSkipped).toBe(1);
+    expect(record.errorCount).toBe(0);
+    expect(record.startedAt >= before).toBe(true);
+    expect(record.completedAt <= after).toBe(true);
+  });
+});
+
+// ── Concurrent ────────────────────────────────────────────────────────────────
+
+describe('concurrent mode', () => {
+  it('both running events arrive before either done event', async () => {
+    const events: ServerMessage[] = [];
+    const emit = (msg: ServerMessage) => events.push(msg);
+
+    const delayed = (): Promise<TaskResult> =>
+      new Promise(res => setTimeout(() => res({ inserted: 1, skipped: 0, insertedIds: ['x'], insertedTransactions: [], changedTransactions: [] }), 20));
+
+    await startRun([makeTask('src-1', delayed), makeTask('src-2', delayed)], true, emit);
+
+    const runningIdxs = events.flatMap((e, i) => (e.type === 'task-running' ? [i] : []));
+    const doneIdxs = events.flatMap((e, i) => (e.type === 'task-done' ? [i] : []));
+
+    expect(runningIdxs).toHaveLength(2);
+    expect(doneIdxs).toHaveLength(2);
+    expect(Math.max(...runningIdxs)).toBeLessThan(Math.min(...doneIdxs));
+  });
+
+  it('totals reflect both tasks', async () => {
+    const record = await startRun(
+      [makeTask('src-1'), makeTask('src-2')],
+      true,
+      () => {},
+    );
+    expect(record.totalInserted).toBe(4);
+    expect(record.totalSkipped).toBe(2);
+  });
+});
+
+// ── Task error ────────────────────────────────────────────────────────────────
+
+describe('task error handling', () => {
+  it('emits task-error when run() throws, other task still completes', async () => {
+    const events: ServerMessage[] = [];
+    const emit = (msg: ServerMessage) => events.push(msg);
+
+    const failing = makeTask('src-1', async () => {
+      throw new Error('Scraper exploded');
+    });
+
+    await startRun([failing, makeTask('src-2')], false, emit);
+
+    const taskError = events.find(
+      e => e.type === 'task-error' && 'sourceId' in e && e.sourceId === 'src-1',
+    );
+    expect(taskError).toBeTruthy();
+    expect((taskError as { message: string }).message).toContain('Scraper exploded');
+
+    expect(events.some(e => e.type === 'task-done' && 'sourceId' in e && e.sourceId === 'src-2')).toBe(true);
+    expect(events.at(-1)).toMatchObject({ type: 'run-complete', errors: 1 });
+  });
+
+  it('run-complete totals reflect only the successful task', async () => {
+    const record = await startRun(
+      [
+        makeTask('src-1', async () => {
+          throw new Error('fail');
+        }),
+        makeTask('src-2'),
+      ],
+      false,
+      () => {},
+    );
+    expect(record.totalInserted).toBe(2); // only src-2
+    expect(record.totalSkipped).toBe(1);
+  });
+});
+
+// ── In-progress guard ─────────────────────────────────────────────────────────
+
+describe('in-progress guard', () => {
+  it('throws when called while a run is already in progress', async () => {
+    const neverResolves = (): Promise<TaskResult> => new Promise(_r => {});
+
+    // Start a run that never finishes (don't await it)
+    const firstRun = startRun([makeTask('src-1', neverResolves)], false, () => {});
+
+    // Second call should reject immediately because _running is already true
+    await expect(startRun([makeTask('src-2')], false, () => {})).rejects.toThrow(
+      'Run already in progress',
+    );
+
+    // Cleanup: _resetRunState is called in afterEach, firstRun hangs but that's OK
+    void firstRun;
+  });
+});

package/src/server/__tests__/settings-routes.test.ts

@@ -0,0 +1,117 @@
+import { randomBytes } from 'node:crypto';
+import { rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import Fastify, { type FastifyInstance } from 'fastify';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { defaultVault, saveVaultFile } from '../vault.js';
+import { lockVault } from '../vault-store.js';
+import { registerVaultRoutes } from '../vault-routes.js';
+
+const PASSWORD = 'test-password-123';
+
+let vaultPath: string;
+let app: FastifyInstance;
+
+beforeEach(async () => {
+  vaultPath = join(tmpdir(), `vault-test-${randomBytes(4).toString('hex')}.vault`);
+  process.env['VAULT_PATH'] = vaultPath;
+  await saveVaultFile(vaultPath, defaultVault(), PASSWORD);
+
+  app = Fastify();
+  await registerVaultRoutes(app);
+  await app.ready();
+
+  await app.inject({
+    method: 'POST',
+    url: '/api/vault/unlock',
+    payload: { password: PASSWORD },
+  });
+});
+
+afterEach(async () => {
+  lockVault();
+  await app.close();
+  await rm(vaultPath, { force: true });
+  delete process.env['VAULT_PATH'];
+});
+
+describe('GET /api/vault/settings', () => {
+  it('returns default settings after unlock', async () => {
+    const res = await app.inject({ method: 'GET', url: '/api/vault/settings' });
+    expect(res.statusCode).toBe(200);
+    expect(res.json()).toMatchObject({
+      showBrowser: false,
+      fetchBankOfIsraelRates: true,
+      concurrentScraping: false,
+    });
+  });
+
+  it('returns 401 when vault is locked', async () => {
+    lockVault();
+    const res = await app.inject({ method: 'GET', url: '/api/vault/settings' });
+    expect(res.statusCode).toBe(401);
+  });
+});
+
+describe('PUT /api/vault/settings', () => {
+  it('merges partial update and persists', async () => {
+    const res = await app.inject({
+      method: 'PUT',
+      url: '/api/vault/settings',
+      payload: { showBrowser: true, serverUrl: 'https://example.com' },
+    });
+    expect(res.statusCode).toBe(200);
+    const settings = res.json() as Record<string, unknown>;
+    expect(settings.showBrowser).toBe(true);
+    expect(settings.serverUrl).toBe('https://example.com');
+    expect(settings.fetchBankOfIsraelRates).toBe(true);
+  });
+
+  it('GET after PUT reflects saved value', async () => {
+    await app.inject({
+      method: 'PUT',
+      url: '/api/vault/settings',
+      payload: { apiKey: 'my-key' },
+    });
+    const res = await app.inject({ method: 'GET', url: '/api/vault/settings' });
+    expect(res.json()).toMatchObject({ apiKey: 'my-key' });
+  });
+
+  it('survives re-lock and re-unlock (persisted to disk)', async () => {
+    await app.inject({
+      method: 'PUT',
+      url: '/api/vault/settings',
+      payload: { serverUrl: 'https://persisted.example' },
+    });
+
+    lockVault();
+    await app.inject({
+      method: 'POST',
+      url: '/api/vault/unlock',
+      payload: { password: PASSWORD },
+    });
+
+    const res = await app.inject({ method: 'GET', url: '/api/vault/settings' });
+    expect(res.json()).toMatchObject({ serverUrl: 'https://persisted.example' });
+  });
+
+  it('returns 401 when vault is locked', async () => {
+    lockVault();
+    const res = await app.inject({
+      method: 'PUT',
+      url: '/api/vault/settings',
+      payload: { showBrowser: true },
+    });
+    expect(res.statusCode).toBe(401);
+  });
+
+  it('returns 400 for invalid field types', async () => {
+    const res = await app.inject({
+      method: 'PUT',
+      url: '/api/vault/settings',
+      payload: { showBrowser: 'not-a-boolean' },
+    });
+    expect(res.statusCode).toBe(400);
+  });
+});

package/src/server/__tests__/sources-routes.test.ts

@@ -0,0 +1,149 @@
+import { randomBytes } from 'node:crypto';
+import { rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import Fastify, { type FastifyInstance } from 'fastify';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { defaultVault, saveVaultFile } from '../vault.js';
+import { lockVault } from '../vault-store.js';
+import { registerVaultRoutes } from '../vault-routes.js';
+
+const PASSWORD = 'test-password-123';
+
+let vaultPath: string;
+let app: FastifyInstance;
+
+beforeEach(async () => {
+  vaultPath = join(tmpdir(), `vault-test-${randomBytes(4).toString('hex')}.vault`);
+  process.env['VAULT_PATH'] = vaultPath;
+  await saveVaultFile(vaultPath, defaultVault(), PASSWORD);
+
+  app = Fastify();
+  await registerVaultRoutes(app);
+  await app.ready();
+
+  await app.inject({
+    method: 'POST',
+    url: '/api/vault/unlock',
+    payload: { password: PASSWORD },
+  });
+});
+
+afterEach(async () => {
+  lockVault();
+  await app.close();
+  await rm(vaultPath, { force: true });
+  delete process.env['VAULT_PATH'];
+});
+
+describe('GET /api/vault/sources', () => {
+  it('returns empty list initially', async () => {
+    const res = await app.inject({ method: 'GET', url: '/api/vault/sources' });
+    expect(res.statusCode).toBe(200);
+    expect(res.json()).toEqual([]);
+  });
+
+  it('returns 401 when vault is locked', async () => {
+    lockVault();
+    const res = await app.inject({ method: 'GET', url: '/api/vault/sources' });
+    expect(res.statusCode).toBe(401);
+  });
+});
+
+describe('POST /api/vault/sources', () => {
+  it('appends a poalim source and returns updated list', async () => {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/api/vault/sources',
+      payload: { type: 'poalim', userCode: 'user1', password: 'pass1' },
+    });
+    expect(res.statusCode).toBe(200);
+    const list = res.json() as Array<{ type: string; userCode: string; id: string }>;
+    expect(list).toHaveLength(1);
+    expect(list[0].type).toBe('poalim');
+    expect(list[0].userCode).toBe('user1');
+    expect(list[0].id).toBeTruthy();
+  });
+
+  it('appends a discount source', async () => {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/api/vault/sources',
+      payload: { type: 'discount', ID: 'D123', password: 'pass2' },
+    });
+    expect(res.statusCode).toBe(200);
+    const list = res.json() as Array<{ type: string }>;
+    expect(list[0].type).toBe('discount');
+  });
+
+  it('returns 400 for missing required fields', async () => {
+    const res = await app.inject({
+      method: 'POST',
+      url: '/api/vault/sources',
+      payload: { type: 'poalim' },
+    });
+    expect(res.statusCode).toBe(400);
+  });
+
+  it('returns 401 when vault is locked', async () => {
+    lockVault();
+    const res = await app.inject({
+      method: 'POST',
+      url: '/api/vault/sources',
+      payload: { type: 'poalim', userCode: 'user1', password: 'pass1' },
+    });
+    expect(res.statusCode).toBe(401);
+  });
+});
+
+describe('PUT /api/vault/sources/:id', () => {
+  it('updates a source and returns updated list', async () => {
+    const addRes = await app.inject({
+      method: 'POST',
+      url: '/api/vault/sources',
+      payload: { type: 'poalim', userCode: 'user1', password: 'pass1' },
+    });
+    const [added] = addRes.json() as Array<{ id: string; nickname?: string }>;
+
+    const res = await app.inject({
+      method: 'PUT',
+      url: `/api/vault/sources/${added.id}`,
+      payload: { nickname: 'My Poalim' },
+    });
+    expect(res.statusCode).toBe(200);
+    const list = res.json() as Array<{ id: string; nickname?: string }>;
+    expect(list[0].nickname).toBe('My Poalim');
+  });
+
+  it('returns 404 for unknown id', async () => {
+    const res = await app.inject({
+      method: 'PUT',
+      url: '/api/vault/sources/does-not-exist',
+      payload: { nickname: 'x' },
+    });
+    expect(res.statusCode).toBe(404);
+  });
+});
+
+describe('DELETE /api/vault/sources/:id', () => {
+  it('removes a source and returns updated list', async () => {
+    const addRes = await app.inject({
+      method: 'POST',
+      url: '/api/vault/sources',
+      payload: { type: 'max', username: 'maxuser', password: 'pass3' },
+    });
+    const [added] = addRes.json() as Array<{ id: string }>;
+
+    const res = await app.inject({
+      method: 'DELETE',
+      url: `/api/vault/sources/${added.id}`,
+    });
+    expect(res.statusCode).toBe(200);
+    expect(res.json()).toEqual([]);
+  });
+
+  it('returns 404 for unknown id', async () => {
+    const res = await app.inject({ method: 'DELETE', url: '/api/vault/sources/ghost' });
+    expect(res.statusCode).toBe(404);
+  });
+});