@accounter/scraper-app 0.0.1

package/src/server/scrapers/__tests__/currency-rates.test.ts

@@ -0,0 +1,105 @@
+import { describe, expect, it, vi, afterEach } from 'vitest';
+import { scrapeCurrencyRates } from '../currency-rates.js';
+
+const noop = () => {};
+
+// Minimal valid BOI XML with one currency (USD) and one past date
+const VALID_BOI_XML = `<?xml version="1.0" encoding="UTF-8"?>
+<message:StructureSpecificData xmlns:message="http://www.sdmx.org/resources/sdmxml/schemas/v2_1/message">
+  <message:DataSet>
+    <Series BASE_CURRENCY="USD">
+      <Obs TIME_PERIOD="2024-01-01" OBS_VALUE="3.65"/>
+    </Series>
+  </message:DataSet>
+</message:StructureSpecificData>`;
+
+// XML with an unsupported currency
+const BAD_CURRENCY_XML = `<?xml version="1.0" encoding="UTF-8"?>
+<message:StructureSpecificData xmlns:message="http://www.sdmx.org/resources/sdmxml/schemas/v2_1/message">
+  <message:DataSet>
+    <Series BASE_CURRENCY="XYZ">
+      <Obs TIME_PERIOD="2024-01-01" OBS_VALUE="1.0"/>
+    </Series>
+  </message:DataSet>
+</message:StructureSpecificData>`;
+
+// XML that produces no valid entries (empty series)
+const EMPTY_BOI_XML = `<?xml version="1.0" encoding="UTF-8"?>
+<message:StructureSpecificData xmlns:message="http://www.sdmx.org/resources/sdmxml/schemas/v2_1/message">
+  <message:DataSet>
+  </message:DataSet>
+</message:StructureSpecificData>`;
+
+function mockFetch(xml: string, ok = true) {
+  vi.stubGlobal(
+    'fetch',
+    vi.fn().mockResolvedValue({
+      ok,
+      status: ok ? 200 : 500,
+      statusText: ok ? 'OK' : 'Internal Server Error',
+      text: () => Promise.resolve(xml),
+    }),
+  );
+}
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+});
+
+describe('scrapeCurrencyRates — happy path', () => {
+  it('resolves with a validated CurrencyRatesPayload', async () => {
+    mockFetch(VALID_BOI_XML);
+
+    const result = await scrapeCurrencyRates(noop);
+
+    expect(Array.isArray(result)).toBe(true);
+    expect(result.length).toBeGreaterThan(0);
+    expect(result[0]).toMatchObject({ date: '2024-01-01', currency: 'USD', rate: 3.65 });
+  });
+});
+
+describe('scrapeCurrencyRates — fetch error', () => {
+  it('throws when the BOI fetch returns a non-OK status', async () => {
+    mockFetch('', false);
+
+    await expect(scrapeCurrencyRates(noop)).rejects.toThrow('BOI fetch failed');
+  });
+});
+
+describe('scrapeCurrencyRates — empty response', () => {
+  it('returns an empty array when no valid series are found', async () => {
+    mockFetch(EMPTY_BOI_XML);
+
+    // No series → no entries → empty validated array
+    const result = await scrapeCurrencyRates(noop);
+    expect(result).toEqual([]);
+  });
+});
+
+describe('scrapeCurrencyRates — unsupported currency', () => {
+  it('skips entries with unsupported currencies without throwing', async () => {
+    mockFetch(BAD_CURRENCY_XML);
+
+    const result = await scrapeCurrencyRates(noop);
+    expect(result).toEqual([]);
+  });
+});
+
+describe('scrapeCurrencyRates — NaN rate', () => {
+  it('skips entries where OBS_VALUE is not a valid number', async () => {
+    const badRateXml = `<?xml version="1.0" encoding="UTF-8"?>
+<message:StructureSpecificData xmlns:message="http://www.sdmx.org/resources/sdmxml/schemas/v2_1/message">
+  <message:DataSet>
+    <Series BASE_CURRENCY="USD">
+      <Obs TIME_PERIOD="2024-01-01" OBS_VALUE="not-a-number"/>
+    </Series>
+  </message:DataSet>
+</message:StructureSpecificData>`;
+
+    mockFetch(badRateXml);
+
+    // NaN is filtered out by the isNaN guard, resulting in an empty array
+    const result = await scrapeCurrencyRates(noop);
+    expect(result).toEqual([]);
+  });
+});

package/src/server/scrapers/__tests__/discount.test.ts

@@ -0,0 +1,160 @@
+import { describe, expect, it, vi } from 'vitest';
+import { PayloadValidationError } from '../../validate-payload.js';
+import { scrapeDiscount } from '../discount.js';
+
+const CREDS = { id: 'src-1', ID: '123456789', password: 'pass' };
+const DATE_FROM = new Date('2024-01-01');
+const DATE_TO = new Date('2024-01-31');
+const noop = () => {};
+
+const VALID_MONTH_RESULT = {
+  success: true,
+  accountNumber: 'ACC-001',
+  balance: 5000,
+  transactions: [
+    {
+      OperationDate: '20240101',
+      ValueDate: '20240101',
+      OperationCode: '1',
+      OperationDescription: 'Credit',
+      OperationAmount: 1000,
+      BalanceAfterOperation: 5000,
+      OperationNumber: 1,
+      OperationDescription2: '',
+      OperationDescription3: '',
+      OperationBranch: 1,
+      OperationBank: 1,
+      Channel: 'web',
+      ChannelName: 'Web',
+      InstituteCode: '1',
+      BranchTreasuryNumber: '1',
+      Urn: 'urn-1',
+      OperationDetailsServiceName: '',
+      CommissionChannelCode: '',
+      CommissionChannelName: '',
+      CommissionTypeName: '',
+      BusinessDayDate: '20240101',
+      EventName: '',
+      CategoryCode: 1,
+      CategoryDescCode: 1,
+      CategoryDescription: '',
+      OperationDescriptionToDisplay: 'Credit',
+      OperationOrder: 1,
+      IsLastSeen: false,
+    },
+  ],
+};
+
+vi.mock('@accounter/modern-poalim-scraper', () => ({
+  init: vi.fn(),
+}));
+
+async function getInitMock() {
+  const mod = await import('@accounter/modern-poalim-scraper');
+  return mod.init as ReturnType<typeof vi.fn>;
+}
+
+describe('scrapeDiscount — happy path', () => {
+  it('resolves with a validated DiscountPayload containing one entry per month', async () => {
+    const initMock = await getInitMock();
+    initMock.mockResolvedValue({
+      discount: vi.fn().mockResolvedValue({
+        getMonthTransactions: vi.fn().mockResolvedValue(VALID_MONTH_RESULT),
+      }),
+      close: vi.fn().mockResolvedValue(undefined),
+    });
+
+    const result = await scrapeDiscount(CREDS, DATE_FROM, DATE_TO, noop);
+    expect(Array.isArray(result)).toBe(true);
+    expect(result).toHaveLength(1);
+    expect(result[0]).toMatchObject({
+      accountNumber: 'ACC-001',
+      month: '2024-01',
+      balance: 5000,
+    });
+    expect(result[0]!.transactions).toHaveLength(1);
+  });
+
+  it('fetches one month per month in the date range', async () => {
+    const getMonthTransactions = vi.fn().mockResolvedValue(VALID_MONTH_RESULT);
+    const initMock = await getInitMock();
+    initMock.mockResolvedValue({
+      discount: vi.fn().mockResolvedValue({ getMonthTransactions }),
+      close: vi.fn().mockResolvedValue(undefined),
+    });
+
+    const threeMonthsFrom = new Date('2024-01-01');
+    const threeMonthsTo = new Date('2024-03-31');
+    const result = await scrapeDiscount(CREDS, threeMonthsFrom, threeMonthsTo, noop);
+
+    expect(getMonthTransactions).toHaveBeenCalledTimes(3);
+    expect(result).toHaveLength(3);
+    expect(result.map(r => r.month)).toEqual(['2024-01', '2024-02', '2024-03']);
+  });
+
+  it('passes the correct month Date to getMonthTransactions', async () => {
+    const getMonthTransactions = vi.fn().mockResolvedValue(VALID_MONTH_RESULT);
+    const initMock = await getInitMock();
+    initMock.mockResolvedValue({
+      discount: vi.fn().mockResolvedValue({ getMonthTransactions }),
+      close: vi.fn().mockResolvedValue(undefined),
+    });
+
+    await scrapeDiscount(CREDS, DATE_FROM, DATE_TO, noop);
+    expect(getMonthTransactions).toHaveBeenCalledWith(expect.any(Date));
+  });
+
+  it('calls close() even on success', async () => {
+    const close = vi.fn().mockResolvedValue(undefined);
+    const initMock = await getInitMock();
+    initMock.mockResolvedValue({
+      discount: vi.fn().mockResolvedValue({
+        getMonthTransactions: vi.fn().mockResolvedValue(VALID_MONTH_RESULT),
+      }),
+      close,
+    });
+
+    await scrapeDiscount(CREDS, DATE_FROM, DATE_TO, noop);
+    expect(close).toHaveBeenCalledOnce();
+  });
+});
+
+describe('scrapeDiscount — invalid payload', () => {
+  it('throws PayloadValidationError when data fails schema validation', async () => {
+    const initMock = await getInitMock();
+    initMock.mockResolvedValue({
+      discount: vi.fn().mockResolvedValue({
+        getMonthTransactions: vi.fn().mockResolvedValue({
+          success: true,
+          accountNumber: 'ACC-001',
+          balance: 0,
+          transactions: [{ OperationDate: 'bad' }], // missing required fields
+        }),
+      }),
+      close: vi.fn().mockResolvedValue(undefined),
+    });
+
+    await expect(scrapeDiscount(CREDS, DATE_FROM, DATE_TO, noop)).rejects.toBeInstanceOf(
+      PayloadValidationError,
+    );
+  });
+
+  it('calls close() even on validation error', async () => {
+    const close = vi.fn().mockResolvedValue(undefined);
+    const initMock = await getInitMock();
+    initMock.mockResolvedValue({
+      discount: vi.fn().mockResolvedValue({
+        getMonthTransactions: vi.fn().mockResolvedValue({
+          success: true,
+          accountNumber: 'ACC-001',
+          balance: 0,
+          transactions: [{ OperationDate: 'bad' }],
+        }),
+      }),
+      close,
+    });
+
+    await expect(scrapeDiscount(CREDS, DATE_FROM, DATE_TO, noop)).rejects.toThrow();
+    expect(close).toHaveBeenCalledOnce();
+  });
+});

package/src/server/scrapers/__tests__/isracard.test.ts

@@ -0,0 +1,142 @@
+import { describe, expect, it, vi } from 'vitest';
+import { PayloadValidationError } from '../../validate-payload.js';
+import { scrapeIsracard } from '../isracard.js';
+
+const CREDS = { id: 'src-1', ownerId: '123456789', password: 'pass', last6Digits: '123456' };
+
+const VALID_PAYLOAD = {
+  Header: { Status: '1', Message: null },
+  CardsTransactionsListBean: {
+    cardNumberList: ['123456'],
+    Index0: { '@AllCards': 'AllCards', CurrentCardTransactions: [] },
+  },
+};
+
+const DATE_FROM = new Date('2024-01-01');
+const DATE_TO = new Date('2024-01-31');
+const noop = () => {};
+
+vi.mock('@accounter/modern-poalim-scraper', () => ({
+  init: vi.fn(),
+}));
+
+async function getInitMock() {
+  const mod = await import('@accounter/modern-poalim-scraper');
+  return mod.init as ReturnType<typeof vi.fn>;
+}
+
+describe('scrapeIsracard — happy path', () => {
+  it('resolves with an array of validated IsracardPayloads', async () => {
+    const initMock = await getInitMock();
+    initMock.mockResolvedValue({
+      isracard: vi.fn().mockResolvedValue({
+        getMonthTransactions: vi.fn().mockResolvedValue({ data: VALID_PAYLOAD, isValid: true }),
+      }),
+      close: vi.fn().mockResolvedValue(undefined),
+    });
+
+    const result = await scrapeIsracard(CREDS, DATE_FROM, DATE_TO, noop);
+    expect(Array.isArray(result)).toBe(true);
+    expect(result).toHaveLength(1);
+    expect(result[0]!.Header.Status).toBe('1');
+  });
+
+  it('fetches one month per month in the date range', async () => {
+    const getMonthTransactions = vi
+      .fn()
+      .mockResolvedValue({ data: VALID_PAYLOAD, isValid: true });
+    const initMock = await getInitMock();
+    initMock.mockResolvedValue({
+      isracard: vi.fn().mockResolvedValue({ getMonthTransactions }),
+      close: vi.fn().mockResolvedValue(undefined),
+    });
+
+    const threeMonthsFrom = new Date('2024-01-01');
+    const threeMonthsTo = new Date('2024-03-31');
+    await scrapeIsracard(CREDS, threeMonthsFrom, threeMonthsTo, noop);
+
+    expect(getMonthTransactions).toHaveBeenCalledTimes(3);
+  });
+
+  it('skips months where data is null', async () => {
+    const initMock = await getInitMock();
+    initMock.mockResolvedValue({
+      isracard: vi.fn().mockResolvedValue({
+        getMonthTransactions: vi.fn().mockResolvedValue({ data: null, isValid: null }),
+      }),
+      close: vi.fn().mockResolvedValue(undefined),
+    });
+
+    const result = await scrapeIsracard(CREDS, DATE_FROM, DATE_TO, noop);
+    expect(result).toEqual([]);
+  });
+
+  it('calls close() even on success', async () => {
+    const close = vi.fn().mockResolvedValue(undefined);
+    const initMock = await getInitMock();
+    initMock.mockResolvedValue({
+      isracard: vi.fn().mockResolvedValue({
+        getMonthTransactions: vi.fn().mockResolvedValue({ data: VALID_PAYLOAD, isValid: true }),
+      }),
+      close,
+    });
+
+    await scrapeIsracard(CREDS, DATE_FROM, DATE_TO, noop);
+    expect(close).toHaveBeenCalledOnce();
+  });
+});
+
+describe('scrapeIsracard — Header.Status check', () => {
+  it('throws when Header.Status is not "1"', async () => {
+    const initMock = await getInitMock();
+    initMock.mockResolvedValue({
+      isracard: vi.fn().mockResolvedValue({
+        getMonthTransactions: vi.fn().mockResolvedValue({
+          data: { ...VALID_PAYLOAD, Header: { Status: '2', Message: 'Replace password' } },
+          isValid: true,
+        }),
+      }),
+      close: vi.fn().mockResolvedValue(undefined),
+    });
+
+    await expect(scrapeIsracard(CREDS, DATE_FROM, DATE_TO, noop)).rejects.toThrow(
+      'login/password issue',
+    );
+  });
+});
+
+describe('scrapeIsracard — invalid payload', () => {
+  it('throws PayloadValidationError when data fails schema validation', async () => {
+    const initMock = await getInitMock();
+    initMock.mockResolvedValue({
+      isracard: vi.fn().mockResolvedValue({
+        getMonthTransactions: vi.fn().mockResolvedValue({
+          data: { Header: { Status: '1', Message: null }, unexpected: 'shape' },
+          isValid: true,
+        }),
+      }),
+      close: vi.fn().mockResolvedValue(undefined),
+    });
+
+    await expect(scrapeIsracard(CREDS, DATE_FROM, DATE_TO, noop)).rejects.toBeInstanceOf(
+      PayloadValidationError,
+    );
+  });
+
+  it('calls close() even on validation error', async () => {
+    const close = vi.fn().mockResolvedValue(undefined);
+    const initMock = await getInitMock();
+    initMock.mockResolvedValue({
+      isracard: vi.fn().mockResolvedValue({
+        getMonthTransactions: vi.fn().mockResolvedValue({
+          data: { Header: { Status: '1', Message: null }, unexpected: 'shape' },
+          isValid: true,
+        }),
+      }),
+      close,
+    });
+
+    await expect(scrapeIsracard(CREDS, DATE_FROM, DATE_TO, noop)).rejects.toThrow();
+    expect(close).toHaveBeenCalledOnce();
+  });
+});

package/src/server/scrapers/__tests__/max.test.ts

@@ -0,0 +1,115 @@
+import { describe, expect, it, vi } from 'vitest';
+import { PayloadValidationError } from '../../validate-payload.js';
+import { scrapeMax } from '../max.js';
+
+const CREDS = { id: 'src-1', username: 'user', password: 'pass' };
+const DATE_FROM = new Date('2024-01-01');
+const DATE_TO = new Date('2024-01-31');
+const noop = () => {};
+
+const VALID_PAYLOAD = [
+  { accountNumber: '1234', txns: [] },
+];
+
+vi.mock('@accounter/modern-poalim-scraper', () => ({
+  init: vi.fn(),
+}));
+
+async function getInitMock() {
+  const mod = await import('@accounter/modern-poalim-scraper');
+  return mod.init as ReturnType<typeof vi.fn>;
+}
+
+describe('scrapeMax — happy path', () => {
+  it('resolves with a validated MaxPayload (array of accounts)', async () => {
+    const initMock = await getInitMock();
+    initMock.mockResolvedValue({
+      max: vi.fn().mockResolvedValue({
+        getTransactions: vi.fn().mockResolvedValue(VALID_PAYLOAD),
+      }),
+      close: vi.fn().mockResolvedValue(undefined),
+    });
+
+    const result = await scrapeMax(CREDS, DATE_FROM, DATE_TO, noop);
+    expect(Array.isArray(result)).toBe(true);
+    expect(result).toHaveLength(1);
+    expect(result[0]!.accountNumber).toBe('1234');
+    expect(result[0]!.txns).toEqual([]);
+  });
+
+  it('passes startDate to the scraper via MaxOptions', async () => {
+    const maxFn = vi.fn().mockResolvedValue({
+      getTransactions: vi.fn().mockResolvedValue(VALID_PAYLOAD),
+    });
+    const initMock = await getInitMock();
+    initMock.mockResolvedValue({ max: maxFn, close: vi.fn().mockResolvedValue(undefined) });
+
+    await scrapeMax(CREDS, DATE_FROM, DATE_TO, noop);
+
+    expect(maxFn).toHaveBeenCalledWith(
+      { username: 'user', password: 'pass' },
+      { startDate: DATE_FROM },
+    );
+  });
+
+  it('returns multiple accounts when the scraper reports them', async () => {
+    const multiAccountPayload = [
+      { accountNumber: 'ACC-1', txns: [] },
+      { accountNumber: 'ACC-2', txns: [] },
+    ];
+    const initMock = await getInitMock();
+    initMock.mockResolvedValue({
+      max: vi.fn().mockResolvedValue({
+        getTransactions: vi.fn().mockResolvedValue(multiAccountPayload),
+      }),
+      close: vi.fn().mockResolvedValue(undefined),
+    });
+
+    const result = await scrapeMax(CREDS, DATE_FROM, DATE_TO, noop);
+    expect(result.map(a => a.accountNumber)).toEqual(['ACC-1', 'ACC-2']);
+  });
+
+  it('calls close() even on success', async () => {
+    const close = vi.fn().mockResolvedValue(undefined);
+    const initMock = await getInitMock();
+    initMock.mockResolvedValue({
+      max: vi.fn().mockResolvedValue({
+        getTransactions: vi.fn().mockResolvedValue(VALID_PAYLOAD),
+      }),
+      close,
+    });
+
+    await scrapeMax(CREDS, DATE_FROM, DATE_TO, noop);
+    expect(close).toHaveBeenCalledOnce();
+  });
+});
+
+describe('scrapeMax — invalid payload', () => {
+  it('throws PayloadValidationError when data fails schema validation', async () => {
+    const initMock = await getInitMock();
+    initMock.mockResolvedValue({
+      max: vi.fn().mockResolvedValue({
+        getTransactions: vi.fn().mockResolvedValue('not-an-array'),
+      }),
+      close: vi.fn().mockResolvedValue(undefined),
+    });
+
+    await expect(scrapeMax(CREDS, DATE_FROM, DATE_TO, noop)).rejects.toBeInstanceOf(
+      PayloadValidationError,
+    );
+  });
+
+  it('calls close() even on validation error', async () => {
+    const close = vi.fn().mockResolvedValue(undefined);
+    const initMock = await getInitMock();
+    initMock.mockResolvedValue({
+      max: vi.fn().mockResolvedValue({
+        getTransactions: vi.fn().mockResolvedValue('not-an-array'),
+      }),
+      close,
+    });
+
+    await expect(scrapeMax(CREDS, DATE_FROM, DATE_TO, noop)).rejects.toThrow();
+    expect(close).toHaveBeenCalledOnce();
+  });
+});

package/src/server/scrapers/__tests__/poalim.test.ts

@@ -0,0 +1,154 @@
+import { describe, expect, it, vi } from 'vitest';
+import { OtpManager } from '../../otp-manager.js';
+import { PayloadValidationError } from '../../validate-payload.js';
+import { scrapePoalim } from '../poalim.js';
+
+const VALID_ACCOUNTS = [{ bankNumber: 12, branchNumber: 600, accountNumber: 100_000 }];
+
+const VALID_ILS_DATA = {
+  transactions: [
+    {
+      activityDescription: 'Credit',
+      activityTypeCode: 1,
+      eventAmount: 1000,
+      eventDate: 20_240_101,
+      serialNumber: 1,
+      transactionType: 'REGULAR',
+      currentBalance: 5000,
+      referenceNumber: 12_345,
+    },
+  ],
+  retrievalTransactionData: { accountNumber: 100_000, branchNumber: 600, bankNumber: 12 },
+};
+
+const VALID_FOREIGN_DATA = {
+  balancesAndLimitsDataList: [
+    { currencySwiftCode: 'USD', currencyCode: 1, transactions: [] },
+  ],
+};
+
+const VALID_SWIFT_DATA = { swiftsList: [] };
+
+function makeScraper(overrides: Record<string, unknown> = {}) {
+  return {
+    getAccountsData: vi.fn().mockResolvedValue({ data: VALID_ACCOUNTS, isValid: true }),
+    getILSTransactions: vi.fn().mockResolvedValue({ data: VALID_ILS_DATA, isValid: true }),
+    getForeignTransactions: vi.fn().mockResolvedValue({ data: VALID_FOREIGN_DATA, isValid: true }),
+    getForeignSwiftTransactions: vi.fn().mockResolvedValue({ data: VALID_SWIFT_DATA, isValid: true }),
+    ...overrides,
+  };
+}
+
+const CREDS = { id: 'src-1', userCode: 'user', password: 'pass' };
+const noop = () => {};
+
+vi.mock('@accounter/modern-poalim-scraper', () => ({
+  init: vi.fn(),
+}));
+
+async function getInitMock() {
+  const mod = await import('@accounter/modern-poalim-scraper');
+  return mod.init as ReturnType<typeof vi.fn>;
+}
+
+describe('scrapePoalim — happy path', () => {
+  it('resolves with typed ILS, foreign, and swift payloads', async () => {
+    const scraper = makeScraper();
+    const initMock = await getInitMock();
+    initMock.mockResolvedValue({
+      hapoalim: vi.fn().mockResolvedValue(scraper),
+      close: vi.fn().mockResolvedValue(undefined),
+    });
+
+    const result = await scrapePoalim(CREDS, new Date(), new Date(), true, new OtpManager(), noop);
+
+    expect(result.ils).toHaveLength(1);
+    expect(result.ils[0]!.retrievalTransactionData.accountNumber).toBe(100_000);
+    expect(result.foreign).toHaveLength(1);
+    expect(result.swift).toHaveLength(1);
+  });
+
+  it('calls close() even on success', async () => {
+    const close = vi.fn().mockResolvedValue(undefined);
+    const initMock = await getInitMock();
+    initMock.mockResolvedValue({ hapoalim: vi.fn().mockResolvedValue(makeScraper()), close });
+
+    await scrapePoalim(CREDS, new Date(), new Date(), true, new OtpManager(), noop);
+
+    expect(close).toHaveBeenCalledOnce();
+  });
+});
+
+describe('scrapePoalim — OTP path', () => {
+  it('resolves with OTP when submitOtp is called after waitForOtp', async () => {
+    const otpManager = new OtpManager();
+    const emit = vi.fn();
+
+    const scraper = makeScraper();
+    const initMock = await getInitMock();
+    initMock.mockResolvedValue({
+      hapoalim: vi.fn().mockImplementation(async (_creds: unknown, opts: { otpCallback?: () => Promise<string> }) => {
+        // Simulate scraper triggering OTP
+        if (opts?.otpCallback) {
+          // Resolve the OTP externally while waitForOtp is pending
+          setTimeout(() => otpManager.submitOtp('src-1', '123456'), 10);
+          const otp = await opts.otpCallback();
+          expect(otp).toBe('123456');
+        }
+        return scraper;
+      }),
+      close: vi.fn().mockResolvedValue(undefined),
+    });
+
+    const result = await scrapePoalim(CREDS, new Date(), new Date(), true, otpManager, emit);
+
+    expect(emit).toHaveBeenCalledWith(expect.objectContaining({ type: 'otp-required', sourceId: 'src-1' }));
+    expect(result.ils).toHaveLength(1);
+  });
+});
+
+describe('scrapePoalim — Unknown Error', () => {
+  it('throws when hapoalim returns "Unknown Error"', async () => {
+    const initMock = await getInitMock();
+    initMock.mockResolvedValue({
+      hapoalim: vi.fn().mockResolvedValue('Unknown Error'),
+      close: vi.fn().mockResolvedValue(undefined),
+    });
+
+    await expect(
+      scrapePoalim(CREDS, new Date(), new Date(), true, new OtpManager(), noop),
+    ).rejects.toThrow('Hapoalim login failed');
+  });
+
+  it('calls close() even when Unknown Error is thrown', async () => {
+    const close = vi.fn().mockResolvedValue(undefined);
+    const initMock = await getInitMock();
+    initMock.mockResolvedValue({
+      hapoalim: vi.fn().mockResolvedValue('Unknown Error'),
+      close,
+    });
+
+    await expect(scrapePoalim(CREDS, new Date(), new Date(), true, new OtpManager(), noop)).rejects.toThrow();
+    expect(close).toHaveBeenCalledOnce();
+  });
+});
+
+describe('scrapePoalim — invalid payload', () => {
+  it('throws PayloadValidationError when ILS data fails schema validation', async () => {
+    const scraper = makeScraper({
+      getILSTransactions: vi.fn().mockResolvedValue({
+        data: { transactions: 'not-an-array', retrievalTransactionData: {} },
+        isValid: false,
+      }),
+    });
+    const initMock = await getInitMock();
+    initMock.mockResolvedValue({
+      hapoalim: vi.fn().mockResolvedValue(scraper),
+      close: vi.fn().mockResolvedValue(undefined),
+    });
+
+    await expect(
+      scrapePoalim(CREDS, new Date(), new Date(), true, new OtpManager(), noop),
+    ).rejects.toBeInstanceOf(PayloadValidationError);
+  });
+});