Free, Open Source, Self-Hosted WhatsApp API Gateway
TypeScript apibotgatewayself-hostedwhatsappwhatsapp-apiwhatsapp-automationwhatsapp-botwhatsapp-gatewaywhatsapp-gateway-apiwhatsapp-webwhatsapp-web-api
import '../test-helpers/register-hooks.ts';
import { test, before, afterEach, type TestContext } from 'node:test';
import assert from 'node:assert/strict';
import { createElement } from 'react';
import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
type RTL = typeof import('@testing-library/react');
let rtl: RTL;
let NumberChecker: typeof import('./NumberChecker.tsx').NumberChecker;
let NUMBER_CHECK_BATCH_MAX: typeof import('./NumberChecker.tsx').NUMBER_CHECK_BATCH_MAX;
let ToastProvider: typeof import('../components/Toast.tsx').ToastProvider;
let MemoryRouter: typeof import('react-router-dom').MemoryRouter;
let Routes: typeof import('react-router-dom').Routes;
let Route: typeof import('react-router-dom').Route;
let Link: typeof import('react-router-dom').Link;
let NumberCheckProvider: typeof import('../components/NumberCheckProvider.tsx').NumberCheckProvider;
let useNumberCheck: typeof import('../hooks/useNumberCheck.ts').useNumberCheck;
let RoleProvider: typeof import('../components/RoleProvider.tsx').RoleProvider;
let defaultFetch: typeof fetch;
function jsonResponse(data: unknown, status = 200): Response {
return new Response(JSON.stringify(data), {
status,
headers: { 'Content-Type': 'application/json' },
});
}
function createTestQueryClient() {
return new QueryClient({
defaultOptions: {
queries: {
retry: false,
},
},
});
}
function renderComponent(role = 'operator', queryClient = createTestQueryClient()) {
sessionStorage.setItem('openwa_user_role', role);
return rtl.render(
createElement(
QueryClientProvider,
{ client: queryClient },
createElement(
RoleProvider,
null,
createElement(
ToastProvider,
null,
createElement(NumberCheckProvider, null, createElement(MemoryRouter, null, createElement(NumberChecker))),
),
),
),
);
}
// The page and a second route under the providers App mounts above its routes, with links to move between them.
function renderRoutes() {
sessionStorage.setItem('openwa_user_role', 'operator');
return rtl.render(
createElement(
QueryClientProvider,
{ client: createTestQueryClient() },
createElement(
RoleProvider,
null,
createElement(
ToastProvider,
null,
createElement(
NumberCheckProvider,
null,
createElement(
MemoryRouter,
{ initialEntries: ['/number-checker'] },
createElement(Link, { to: '/elsewhere' }, 'Leave'),
createElement(Link, { to: '/number-checker' }, 'Return'),
createElement(
Routes,
null,
createElement(Route, { path: '/number-checker', element: createElement(NumberChecker) }),
createElement(Route, { path: '/elsewhere', element: createElement('p', null, 'Elsewhere') }),
),
),
),
),
),
),
);
}
// Answers every number lookup with `answer(number)` and returns the numbers looked up, in order.
function stubLookups(answer: (number: string) => Response): string[] {
const lookups: string[] = [];
globalThis.fetch = ((input: RequestInfo | URL) => {
const url = String(input);
if (url.includes('/contacts/check/')) {
const number = url.split('/contacts/check/')[1];
lookups.push(number);
return Promise.resolve(answer(number));
}
return defaultFetch(input);
}) as typeof fetch;
return lookups;
}
const registered = (number: string) => jsonResponse({ number, exists: true, whatsappId: `${number}@c.us` });
async function openBulkTab(): Promise<HTMLTextAreaElement> {
rtl.fireEvent.click(rtl.screen.getByRole('tab', { name: /Bulk/i }));
await rtl.screen.findByRole('option', { name: /Primary Session/ });
return rtl.screen.getByPlaceholderText(/9612345678/i) as HTMLTextAreaElement;
}
before(async () => {
const { installJsdomGlobals } = await import('../test-helpers/jsdom.ts');
await installJsdomGlobals();
defaultFetch = (() =>
Promise.resolve(
jsonResponse([
{
id: 'test-session-1',
name: 'Primary Session',
status: 'ready',
phone: '919876543210',
},
]),
)) as typeof fetch;
globalThis.fetch = defaultFetch;
const { i18nReady } = await import('../i18n/index.ts');
await i18nReady;
rtl = await import('@testing-library/react');
({ MemoryRouter, Routes, Route, Link } = await import('react-router-dom'));
({ NumberCheckProvider } = await import('../components/NumberCheckProvider.tsx'));
({ useNumberCheck } = await import('../hooks/useNumberCheck.ts'));
({ ToastProvider } = await import('../components/Toast.tsx'));
({ RoleProvider } = await import('../components/RoleProvider.tsx'));
({ NumberChecker, NUMBER_CHECK_BATCH_MAX } = await import('./NumberChecker.tsx'));
});
afterEach(() => {
rtl.cleanup();
globalThis.fetch = defaultFetch;
sessionStorage.clear();
});
test('NumberChecker: renders single check form and tabs', () => {
const { getByText, getByPlaceholderText } = renderComponent();
assert.ok(getByText('Check Single Account'));
assert.ok(getByPlaceholderText('e.g. 919876543210 or 6281234567890'));
});
test('NumberChecker: switches to bulk / batch tab when clicked', () => {
const { getByRole, getAllByText } = renderComponent();
const bulkTab = getByRole('tab', { name: /Bulk/i });
rtl.fireEvent.click(bulkTab);
const headings = getAllByText('Bulk Number Checker');
assert.ok(headings.length >= 1);
});
// The +91 rewrite is opt-in: `autoPrefix` is whether the box is ticked before the number is checked.
for (const [raw, autoPrefix, expected] of [
['+65 8123 4567', true, '6581234567'],
['0065 8123 4567', true, '6581234567'],
['+65 8123 4567', false, '6581234567'],
['0065 8123 4567', false, '6581234567'],
['08123456789', false, '08123456789'],
['4155552671', false, '4155552671'],
['9876543210', false, '9876543210'],
['09876543210', false, '09876543210'],
['9109876543210', false, '9109876543210'],
['9876543210', true, '919876543210'],
['09876543210', true, '919876543210'],
['08123456789', true, '918123456789'],
] as const) {
test(`NumberChecker: checks ${raw} as ${expected} with auto-prefix ${autoPrefix}`, async () => {
const lookups: string[] = [];
globalThis.fetch = ((input: RequestInfo | URL) => {
const url = String(input);
if (url.includes('/contacts/check/')) {
const number = url.split('/contacts/check/')[1];
lookups.push(number);
return Promise.resolve(jsonResponse({ number, exists: false, whatsappId: null }));
}
return defaultFetch(input);
}) as typeof fetch;
const { container } = renderComponent();
await rtl.screen.findByRole('option', { name: /Primary Session/ });
if (autoPrefix) rtl.fireEvent.click(rtl.screen.getByRole('checkbox'));
assert.equal((rtl.screen.getByRole('checkbox') as HTMLInputElement).checked, autoPrefix);
rtl.fireEvent.change(rtl.screen.getByPlaceholderText(/9876543210/), { target: { value: raw } });
if (raw.startsWith('+') || raw.startsWith('00')) {
assert.ok(!container.querySelector('.nc-format-preview')?.textContent?.includes('auto-prefixed'));
}
rtl.fireEvent.click(rtl.screen.getByRole('button', { name: 'Check' }));
await rtl.screen.findByText('Not Registered', { selector: '.nc-status-badge' });
assert.deepEqual(lookups, [expected]);
});
}
// The preview describes the number that will be looked up, not the digits that were typed.
for (const [typed, autoPrefix, expected] of [
['0065 8123 4567', false, 'Will check as: +6581234567 (10 digits)'],
['+65 8123 4567', true, 'Will check as: +6581234567 (10 digits)'],
['916581234567', false, 'Will check as: +916581234567 (12 digits \u2192 kept as-is)'],
['9876543210', true, 'Will check as: +919876543210 (10 digits \u2192 auto-prefixed with 91)'],
] as const) {
test(`NumberChecker: the preview for ${typed} with auto-prefix ${autoPrefix} reads ${expected}`, async () => {
const { container } = renderComponent();
await rtl.screen.findByRole('option', { name: /Primary Session/ });
if (autoPrefix) rtl.fireEvent.click(rtl.screen.getByRole('checkbox'));
rtl.fireEvent.change(rtl.screen.getByPlaceholderText(/9876543210/), { target: { value: typed } });
assert.equal(container.querySelector('.nc-format-preview')?.textContent, expected);
});
}
test('NumberChecker: bulk parsing deduplicates explicit international numbers without adding +91', async () => {
const lookups: string[] = [];
globalThis.fetch = ((input: RequestInfo | URL) => {
const url = String(input);
if (url.includes('/contacts/check/')) {
const number = url.split('/contacts/check/')[1];
lookups.push(number);
return Promise.resolve(jsonResponse({ number, exists: false, whatsappId: null }));
}
return defaultFetch(input);
}) as typeof fetch;
renderComponent();
const textarea = await openBulkTab();
rtl.fireEvent.click(rtl.screen.getByRole('checkbox'));
rtl.fireEvent.change(textarea, { target: { value: '+65 8123 4567\n0065 8123 4567' } });
assert.match(rtl.screen.getByText(/ten-digit/).textContent ?? '', /0 ten-digit/);
rtl.fireEvent.click(rtl.screen.getByRole('button', { name: /Start Batch Check/i }));
await rtl.screen.findByText('+6581234567');
assert.deepEqual(lookups, ['6581234567']);
});
// A number typed or pasted with another script's decimal digits is the same number: it reaches the gateway in ASCII.
const toDigits = (ascii: string, zero: number) => [...ascii].map(d => String.fromCharCode(zero + Number(d))).join('');
const DIGIT_SCRIPTS = [
['Arabic-Indic', 0x0660],
['Persian', 0x06f0],
['Devanagari', 0x0966],
['Telugu', 0x0c66],
['full-width', 0xff10],
] as const;
for (const [script, zero] of DIGIT_SCRIPTS) {
test(`NumberChecker: ${script} digits are previewed and looked up as ASCII digits`, async () => {
const lookups = stubLookups(registered);
const { container } = renderComponent();
await rtl.screen.findByRole('option', { name: /Primary Session/ });
rtl.fireEvent.change(rtl.screen.getByPlaceholderText(/9876543210/), {
target: { value: toDigits('6281234567891', zero) },
});
assert.match(container.querySelector('.nc-format-preview')?.textContent ?? '', /\+6281234567891 \(13 digits\)/);
rtl.fireEvent.click(rtl.screen.getByRole('button', { name: 'Check' }));
await rtl.screen.findByText('Registered', { selector: '.nc-status-badge' });
assert.deepEqual(lookups, ['6281234567891']);
});
}
test('NumberChecker: a bulk list in several scripts is parsed and deduplicated as ASCII numbers', async () => {
const lookups = stubLookups(registered);
renderComponent();
const textarea = await openBulkTab();
const list = [toDigits('6281234567891', 0x0660), toDigits('6281234567892', 0xff10), '6281234567891'].join('\n');
rtl.fireEvent.change(textarea, { target: { value: list } });
assert.match(rtl.screen.getByText(/unique numbers parsed/).textContent ?? '', /\b2 unique numbers parsed$/);
startBatch();
await rtl.screen.findByText('Completed checking 2 numbers.', {}, { timeout: 3000 });
assert.deepEqual(lookups, ['6281234567891', '6281234567892']);
});
// A plus sign that arrives behind invisible direction marks, or as a full-width character, still marks an international
// number: with the +91 rule on, losing it would look a foreign 10-digit number up as an Indian one.
const char = (code: number) => String.fromCharCode(code);
const WRAPPED_PLUS = [
['direction marks around the number', `${char(0x202a)}+65 8123 4567${char(0x202c)}`],
['a right-to-left mark before the plus', `${char(0x200f)}+65 8123 4567`],
['a full-width plus', `${char(0xff0b)}65 8123 4567`],
] as const;
for (const [label, typed] of WRAPPED_PLUS) {
test(`NumberChecker: with +91 on, ${label} still marks an international number`, async () => {
const lookups = stubLookups(registered);
renderComponent();
await rtl.screen.findByRole('option', { name: /Primary Session/ });
rtl.fireEvent.click(rtl.screen.getByRole('checkbox'));
rtl.fireEvent.change(rtl.screen.getByPlaceholderText(/9876543210/), { target: { value: typed } });
rtl.fireEvent.click(rtl.screen.getByRole('button', { name: 'Check' }));
await rtl.screen.findByText('Registered', { selector: '.nc-status-badge' });
assert.deepEqual(lookups, ['6581234567']);
});
}
// Circled and superscript numbers, and fractions, are list bullets and footnote marks around a number, not digits of it.
const MARKED_NUMBERS = [
['a circled-number bullet before the number', `${char(0x2460)} +62 812 3456 7890`, '6281234567890'],
['a superscript footnote mark after the number', `6281234567890${char(0x00b9)}`, '6281234567890'],
['a superscript two after a plus number', `+65 8123 4567${char(0x00b2)}`, '6581234567'],
['a vulgar fraction after the number', `6281234567890${char(0x00bc)}`, '6281234567890'],
] as const;
for (const [label, typed, expected] of MARKED_NUMBERS) {
test(`NumberChecker: ${label} is not read as digits of the number`, async () => {
const lookups = stubLookups(registered);
renderComponent();
await rtl.screen.findByRole('option', { name: /Primary Session/ });
rtl.fireEvent.change(rtl.screen.getByPlaceholderText(/9876543210/), { target: { value: typed } });
rtl.fireEvent.click(rtl.screen.getByRole('button', { name: 'Check' }));
await rtl.screen.findByText('Registered', { selector: '.nc-status-badge' });
assert.deepEqual(lookups, [expected]);
});
}
test('NumberChecker: a bulk list numbered with circled digits looks up the numbers, not the bullets', async () => {
const lookups = stubLookups(registered);
renderComponent();
const textarea = await openBulkTab();
const bullet = (n: number) => char(0x2460 + n);
rtl.fireEvent.change(textarea, {
target: {
value: `${bullet(0)} +62 812 3456 7890\n${bullet(1)} +62 813 4567 8901\n${bullet(2)} +62 814 5678 9012`,
},
});
startBatch();
await rtl.screen.findByText('Completed checking 3 numbers.', {}, { timeout: 4000 });
assert.deepEqual(lookups, ['6281234567890', '6281345678901', '6281456789012']);
});
// The bulk list is folded before it is split, so the full-width comma and semicolon of a CJK input method separate numbers.
for (const [label, separator] of [
['comma', 0xff0c],
['semicolon', 0xff1b],
] as const) {
test(`NumberChecker: a bulk list separated by the full-width ${label} is several numbers`, async () => {
const lookups = stubLookups(registered);
renderComponent();
const textarea = await openBulkTab();
rtl.fireEvent.change(textarea, { target: { value: `+62 812 3456 7890${char(separator)}+62 813 4567 8901` } });
assert.match(rtl.screen.getByText(/unique numbers parsed/).textContent ?? '', /\b2 unique numbers parsed$/);
startBatch();
await rtl.screen.findByText('Completed checking 2 numbers.', {}, { timeout: 3000 });
assert.deepEqual(lookups, ['6281234567890', '6281345678901']);
});
}
// The single-number preview counts the digits typed after folding them, so ten Devanagari digits still read as a
// ten-digit number that the +91 rule prefixes.
test('NumberChecker: ten Devanagari digits with +91 on show the auto-prefixed preview', async () => {
const { container } = renderComponent();
await rtl.screen.findByRole('option', { name: /Primary Session/ });
rtl.fireEvent.click(rtl.screen.getByRole('checkbox'));
const typed = [...'9876543210'].map(d => char(0x0966 + Number(d))).join('');
rtl.fireEvent.change(rtl.screen.getByPlaceholderText(/9876543210/), { target: { value: typed } });
assert.equal(
container.querySelector('.nc-format-pill.highlight')?.textContent,
'Will check as: +919876543210 (10 digits \u2192 auto-prefixed with 91)',
);
});
test('NumberChecker: a bulk list keeps wrapped and full-width plus numbers international with +91 on', async () => {
const lookups = stubLookups(registered);
renderComponent();
const textarea = await openBulkTab();
rtl.fireEvent.click(rtl.screen.getByRole('checkbox'));
rtl.fireEvent.change(textarea, {
target: { value: WRAPPED_PLUS.map(([, typed]) => typed).join('\n') + `\n${char(0x200f)}+65 9123 4567` },
});
assert.match(rtl.screen.getByText(/unique numbers parsed/).textContent ?? '', /\b2 unique numbers parsed$/);
startBatch();
await rtl.screen.findByText('Completed checking 2 numbers.', {}, { timeout: 3000 });
assert.deepEqual(lookups, ['6581234567', '6591234567']);
});
test('NumberChecker: bulk parsing also splits on the Arabic comma and semicolon', async () => {
stubLookups(registered);
renderComponent();
const textarea = await openBulkTab();
const arabicComma = String.fromCharCode(0x060c);
const arabicSemicolon = String.fromCharCode(0x061b);
rtl.fireEvent.change(textarea, {
target: { value: `+6581234567${arabicComma}+6591234567${arabicSemicolon}+6561234567` },
});
assert.match(rtl.screen.getByText(/unique numbers parsed/).textContent ?? '', /\b3 unique numbers parsed$/);
});
// A spreadsheet copied into the box separates its columns with tabs, so an index column stays a column of its own.
test('NumberChecker: a bulk list copied from a spreadsheet keeps each column apart', async () => {
const lookups = stubLookups(registered);
renderComponent();
const textarea = await openBulkTab();
rtl.fireEvent.change(textarea, { target: { value: '1\t+62 812 3456 7890\n2\t+62 813 4567 8901' } });
assert.match(rtl.screen.getByText(/unique numbers parsed/).textContent ?? '', /\b2 unique numbers parsed$/);
startBatch();
await rtl.screen.findByText('Completed checking 2 numbers.', {}, { timeout: 3000 });
assert.deepEqual(lookups, ['6281234567890', '6281345678901']);
});
test('NumberChecker: numbers and ids are isolated as left-to-right, so a right-to-left page keeps them in order', async () => {
stubLookups(registered);
const { container } = renderComponent();
await rtl.screen.findByRole('option', { name: /Primary Session/ });
rtl.fireEvent.change(rtl.screen.getByPlaceholderText(/9876543210/), { target: { value: '+65 8123 4567' } });
assert.equal(container.querySelector('.nc-format-pill strong')?.getAttribute('dir'), 'ltr');
rtl.fireEvent.click(rtl.screen.getByRole('button', { name: 'Check' }));
await rtl.screen.findByText('Registered', { selector: '.nc-status-badge' });
const phone = container.querySelector('.nc-result-phone bdi');
assert.equal(phone?.getAttribute('dir'), 'ltr');
assert.equal(phone?.textContent, '+6581234567');
const jid = container.querySelector('.nc-detail-value bdi');
assert.equal(jid?.getAttribute('dir'), 'ltr');
assert.equal(jid?.textContent, '[email protected]');
});
test('NumberChecker: the number field and the bulk list are typed left to right, so a right-to-left page keeps the plus sign in front', async () => {
const { container } = renderComponent();
await rtl.screen.findByRole('option', { name: /Primary Session/ });
assert.equal(rtl.screen.getByPlaceholderText(/9876543210/).getAttribute('dir'), 'ltr');
rtl.fireEvent.click(rtl.screen.getByRole('tab', { name: /Bulk/i }));
assert.equal(container.querySelector('.nc-textarea')?.getAttribute('dir'), 'ltr');
});
// A scroller is not focusable by itself in every browser, and an unnamed one is not announced: Safari users on a keyboard
// need the tab stop to scroll the columns that do not fit, and a screen reader needs to know what it is on.
test('NumberChecker: both result tables sit in a named, focusable scroll container that a narrow card does not clip', async () => {
stubLookups(registered);
const { container } = renderComponent();
await rtl.screen.findByRole('option', { name: /Primary Session/ });
rtl.fireEvent.change(rtl.screen.getByPlaceholderText(/9876543210/), { target: { value: '919876543210' } });
rtl.fireEvent.click(rtl.screen.getByRole('button', { name: 'Check' }));
await rtl.screen.findByText('Registered', { selector: '.nc-status-badge' });
const wrapper = () => container.querySelector('.nc-history-table')?.parentElement;
assert.equal(container.querySelectorAll('.nc-history-table').length, 1);
assert.equal(wrapper()?.className, 'nc-table-wrap');
assert.equal(wrapper()?.getAttribute('tabindex'), '0');
assert.equal(wrapper()?.getAttribute('role'), 'region');
assert.equal(wrapper()?.getAttribute('aria-label'), 'Recent Checks');
assert.equal(rtl.screen.getByRole('region', { name: 'Recent Checks' }), wrapper());
rtl.fireEvent.click(rtl.screen.getByRole('tab', { name: /Bulk/i }));
rtl.fireEvent.change(rtl.screen.getByPlaceholderText(/9612345678/i), { target: { value: '911111111111' } });
startBatch();
await rtl.screen.findByText('+911111111111');
assert.equal(container.querySelectorAll('.nc-history-table').length, 1);
assert.equal(wrapper()?.className, 'nc-table-wrap');
assert.equal(wrapper()?.getAttribute('tabindex'), '0');
assert.equal(wrapper()?.getAttribute('role'), 'region');
assert.equal(wrapper()?.getAttribute('aria-label'), 'Bulk Number Checker');
});
test('NumberChecker: the Message Tester button reads as a plain link, because it passes no number along', async () => {
stubLookups(registered);
renderComponent();
await rtl.screen.findByRole('option', { name: /Primary Session/ });
rtl.fireEvent.change(rtl.screen.getByPlaceholderText(/9876543210/), { target: { value: '919876543210' } });
rtl.fireEvent.click(rtl.screen.getByRole('button', { name: 'Check' }));
await rtl.screen.findByText('Registered', { selector: '.nc-status-badge' });
assert.ok(rtl.screen.getByRole('button', { name: 'Go to Message Tester' }));
});
test('NumberChecker: every number and id cell of both result tables is isolated as left-to-right', async () => {
stubLookups(number =>
number === '916581234567' ? jsonResponse({ number, exists: false, whatsappId: null }) : registered(number),
);
const { container } = renderComponent();
await rtl.screen.findByRole('option', { name: /Primary Session/ });
const phone = rtl.screen.getByPlaceholderText(/9876543210/);
const check = () => rtl.screen.getByRole('button', { name: 'Check' });
rtl.fireEvent.change(phone, { target: { value: '+65 8123 4567' } });
rtl.fireEvent.click(check());
await rtl.screen.findByText('Registered', { selector: '.nc-status-badge' });
rtl.fireEvent.change(phone, { target: { value: '916581234567' } });
rtl.fireEvent.click(check());
await rtl.screen.findByText('Unregistered', { selector: '.nc-status-badge' });
// Each row: the dir of the isolating wrapper of its number cell and of its id cell, an id placeholder included.
const isolation = (columns: [number, number]) =>
[...container.querySelectorAll('.nc-history-table tbody tr')].map(row =>
columns.map(column => row.children[column].querySelector('bdi')?.getAttribute('dir')),
);
assert.deepEqual(isolation([0, 2]), [
['ltr', 'ltr'],
['ltr', 'ltr'],
]);
rtl.fireEvent.click(rtl.screen.getByRole('tab', { name: /Bulk/i }));
rtl.fireEvent.change(rtl.screen.getByPlaceholderText(/9612345678/i), { target: { value: '911111111111' } });
startBatch();
await rtl.screen.findByText('+911111111111');
assert.deepEqual(isolation([1, 3]), [['ltr', 'ltr']]);
});
test('NumberChecker: the mode tabs are a tablist that reports the selected tab', () => {
renderComponent();
assert.ok(rtl.screen.getByRole('tablist'));
const tabs = rtl.screen.getAllByRole('tab');
assert.deepEqual(
tabs.map(tab => tab.getAttribute('aria-selected')),
['true', 'false'],
);
rtl.fireEvent.click(tabs[1]);
assert.deepEqual(
tabs.map(tab => tab.getAttribute('aria-selected')),
['false', 'true'],
);
});
test('NumberChecker: the result filters report which one is pressed', async () => {
stubLookups(number =>
number === '911111111111' ? jsonResponse({ message: 'engine hiccup' }, 500) : registered(number),
);
renderComponent();
const textarea = await openBulkTab();
rtl.fireEvent.change(textarea, { target: { value: '911111111111\n912222222222' } });
startBatch();
await rtl.screen.findByText('Completed checking 2 numbers.', {}, { timeout: 3000 });
const pressed = () => rtl.screen.getAllByRole('button', { pressed: true }).map(button => button.textContent);
assert.deepEqual(pressed(), ['All (2)']);
rtl.fireEvent.click(rtl.screen.getByRole('button', { name: /^Failed \(1\)/ }));
assert.deepEqual(pressed(), ['Failed (1)']);
});
test('NumberChecker: the number field and the bulk list are named by their labels, not their placeholders', async () => {
const { container } = renderComponent();
await rtl.screen.findByRole('option', { name: /Primary Session/ });
assert.equal(rtl.screen.getByLabelText('Phone Number').tagName, 'INPUT');
rtl.fireEvent.click(container.querySelectorAll('.nc-tab')[1]);
assert.equal(rtl.screen.getByLabelText(/Numbers to Check/).tagName, 'TEXTAREA');
});
test('NumberChecker: the run progress bar is a progressbar that reports how many numbers were checked', async () => {
// The first lookup answers, the next ones never do, so the run stays at one of three.
globalThis.fetch = ((input: RequestInfo | URL) => {
const url = String(input);
if (!url.includes('/contacts/check/')) return defaultFetch(input);
return url.endsWith('/911111111111')
? Promise.resolve(registered('911111111111'))
: new Promise<Response>(() => {});
}) as typeof fetch;
const { container } = renderComponent();
rtl.fireEvent.click(container.querySelectorAll('.nc-tab')[1]);
await rtl.screen.findByRole('option', { name: /Primary Session/ });
rtl.fireEvent.change(container.querySelector('.nc-textarea')!, { target: { value: THREE_NUMBERS } });
startBatch();
const bar = await rtl.screen.findByRole('progressbar');
assert.equal(bar.getAttribute('aria-valuemin'), '0');
assert.equal(bar.getAttribute('aria-valuemax'), '3');
await rtl.waitFor(() => assert.equal(bar.getAttribute('aria-valuenow'), '1'));
});
test('NumberChecker: a finished single check is announced through a status region that exists beforehand', async () => {
stubLookups(registered);
const { container } = renderComponent();
await rtl.screen.findByRole('option', { name: /Primary Session/ });
const region = container.querySelector('[role="status"]');
assert.ok(region, 'there is no status region before the check');
rtl.fireEvent.change(rtl.screen.getByPlaceholderText(/9876543210/), { target: { value: '+65 8123 4567' } });
rtl.fireEvent.click(rtl.screen.getByRole('button', { name: 'Check' }));
await rtl.screen.findByText('Registered on WhatsApp');
assert.equal(container.querySelector('[role="status"]') === region, true);
assert.match(region.textContent ?? '', /\+6581234567.*Registered on WhatsApp/);
});
test('NumberChecker: the Start and Export buttons wrap onto another row instead of running past a narrow screen', async () => {
stubLookups(registered);
const { container } = renderComponent();
rtl.fireEvent.change(await openBulkTab(), { target: { value: '911111111111' } });
startBatch();
await rtl.screen.findByText('+911111111111');
const row = rtl.screen.getByRole('button', { name: /Export Results/i }).parentElement as HTMLElement;
assert.equal(row.style.display, 'flex');
assert.equal(row.style.flexWrap, 'wrap');
assert.equal(row.contains(container.querySelector('.nc-btn-primary')), true);
});
test('NumberChecker: viewers cannot start single or bulk lookups, including with Enter', async () => {
const lookups: string[] = [];
globalThis.fetch = ((input: RequestInfo | URL) => {
const url = String(input);
if (url.includes('/contacts/check/')) {
lookups.push(url);
return Promise.resolve(jsonResponse({ number: '919876543210', exists: false, whatsappId: null }));
}
return defaultFetch(input);
}) as typeof fetch;
renderComponent('viewer');
await rtl.screen.findByRole('option', { name: /Primary Session/ });
const input = rtl.screen.getByPlaceholderText(/9876543210/);
rtl.fireEvent.change(input, { target: { value: '9876543210' } });
assert.equal((rtl.screen.getByRole('button', { name: 'Check' }) as HTMLButtonElement).disabled, true);
await rtl.act(async () => rtl.fireEvent.keyDown(input, { key: 'Enter' }));
rtl.fireEvent.click(rtl.screen.getByRole('tab', { name: /Bulk/i }));
rtl.fireEvent.change(rtl.screen.getByPlaceholderText(/9612345678/i), { target: { value: '9876543210' } });
assert.equal((rtl.screen.getByRole('button', { name: /Start Batch Check/i }) as HTMLButtonElement).disabled, true);
assert.deepEqual(lookups, []);
});
test('NumberChecker: CSV export neutralizes error formulas and releases its object URL', async t => {
const downloads: Blob[] = [];
t.mock.method(URL, 'createObjectURL', (blob: Blob) => {
downloads.push(blob);
return 'blob:number-checker-csv';
});
const revoke = t.mock.method(URL, 'revokeObjectURL');
t.mock.method(HTMLAnchorElement.prototype, 'click', () => {});
globalThis.fetch = ((input: RequestInfo | URL) => {
if (String(input).includes('/contacts/check/')) {
return Promise.resolve(jsonResponse({ message: '=HYPERLINK("https://example.com","lookup")' }, 500));
}
return defaultFetch(input);
}) as typeof fetch;
renderComponent();
rtl.fireEvent.click(rtl.screen.getByRole('tab', { name: /Bulk/i }));
await rtl.screen.findByRole('option', { name: /Primary Session/ });
rtl.fireEvent.change(rtl.screen.getByPlaceholderText(/9612345678/i), { target: { value: '919999999999' } });
rtl.fireEvent.click(rtl.screen.getByRole('button', { name: /Start Batch Check/i }));
await rtl.screen.findByText('Failed', { selector: '.nc-status-badge' });
rtl.fireEvent.click(rtl.screen.getByRole('button', { name: /Export Results/i }));
assert.equal(downloads.length, 1);
assert.ok((await downloads[0].text()).includes(`"'=HYPERLINK(""https://example.com"",""lookup"")"`));
assert.equal(revoke.mock.callCount(), 1);
assert.deepEqual(revoke.mock.calls[0].arguments, ['blob:number-checker-csv']);
assert.equal(document.querySelector('a[download]'), null);
});
test('NumberChecker: the CSV carries each check as an ISO instant while the table shows the time of day', async t => {
const downloads: Blob[] = [];
t.mock.method(URL, 'createObjectURL', (blob: Blob) => {
downloads.push(blob);
return 'blob:number-checker-csv';
});
t.mock.method(URL, 'revokeObjectURL');
t.mock.method(HTMLAnchorElement.prototype, 'click', () => {});
stubLookups(registered);
const { container } = renderComponent();
const textarea = await openBulkTab();
rtl.fireEvent.change(textarea, { target: { value: '919999999999' } });
rtl.fireEvent.click(rtl.screen.getByRole('button', { name: /Start Batch Check/i }));
await rtl.screen.findByText('+919999999999');
rtl.fireEvent.click(rtl.screen.getByRole('button', { name: /Export Results/i }));
const [, row] = (await downloads[0].text()).split('\n');
const checkedAt = row.split(',').at(-1) ?? '';
assert.match(checkedAt, /^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d{3}Z$/);
assert.equal(Number.isNaN(Date.parse(checkedAt)), false);
const shown = container.querySelector('.nc-history-table tbody td:last-child')?.textContent;
assert.equal(shown, new Date(checkedAt).toLocaleTimeString());
});
// The Phone Number column carries the digits as the gateway answered them: an apostrophe in front would be read
// literally by Excel and by any program that imports the file.
async function exportedFirstCells(numbers: string, answer: (number: string) => Response, t: TestContext) {
const downloads: Blob[] = [];
t.mock.method(URL, 'createObjectURL', (blob: Blob) => {
downloads.push(blob);
return 'blob:number-checker-csv';
});
t.mock.method(URL, 'revokeObjectURL');
t.mock.method(HTMLAnchorElement.prototype, 'click', () => {});
stubLookups(answer);
renderComponent();
rtl.fireEvent.change(await openBulkTab(), { target: { value: numbers } });
startBatch();
await rtl.waitFor(() => rtl.screen.getByRole('button', { name: /Export Results/i }), { timeout: 5000 });
rtl.fireEvent.click(rtl.screen.getByRole('button', { name: /Export Results/i }));
const [, ...rows] = (await downloads[0].text()).split('\n');
return rows.map(row => row.split(',')[0]);
}
test('NumberChecker: the CSV writes each phone number as bare digits, with no apostrophe', async t => {
const cells = await exportedFirstCells(
'919612345678\n08123456789',
number => jsonResponse({ number, exists: false, whatsappId: null }),
t,
);
assert.deepEqual(cells, ['919612345678', '08123456789']);
});
test('NumberChecker: a number typed with a plus is checked and exported as bare digits', async t => {
const cells = await exportedFirstCells(
'+628123456789',
number => jsonResponse({ number, exists: false, whatsappId: null }),
t,
);
assert.deepEqual(cells, ['628123456789']);
});
test('NumberChecker: a number the gateway echoes as a formula is still neutralized once', async t => {
const cells = await exportedFirstCells(
'919612345678',
() => jsonResponse({ number: '=1+1', exists: false, whatsappId: null }),
t,
);
assert.deepEqual(cells, ["'=1+1"]);
});
test('NumberChecker: the export button is described by a note on how a spreadsheet shows long numbers', async t => {
t.mock.method(HTMLAnchorElement.prototype, 'click', () => {});
stubLookups(registered);
renderComponent();
assert.equal(rtl.screen.queryByText(/The file holds every digit/), null);
rtl.fireEvent.change(await openBulkTab(), { target: { value: '919612345678' } });
startBatch();
const button = await rtl.waitFor(() => rtl.screen.getByRole('button', { name: /Export Results/i }), {
timeout: 5000,
});
const note = rtl.screen.getByText(/The file holds every digit.*9\.19612E\+11/);
assert.equal(button.getAttribute('aria-describedby'), note.id);
assert.notEqual(note.id, '');
});
test('NumberChecker: a rejected lookup is recorded as failed with error status, not as unregistered', async t => {
t.mock.method(HTMLAnchorElement.prototype, 'click', () => {});
const recordedDownloads: Blob[] = [];
const realCreateObjectURL = URL.createObjectURL;
URL.createObjectURL = (blob: Blob) => {
recordedDownloads.push(blob);
return 'blob:mock-csv';
};
try {
globalThis.fetch = ((input: RequestInfo | URL) => {
const url = String(input);
if (url.includes('/contacts/check/919999999999')) {
return Promise.resolve(jsonResponse({ message: 'Rate limit exceeded (HTTP 429)' }, 429));
}
return Promise.resolve(
jsonResponse([
{
id: 'test-session-1',
name: 'Primary Session',
status: 'ready',
phone: '919876543210',
},
]),
);
}) as typeof fetch;
renderComponent();
// Switch to bulk tab
const bulkTab = rtl.screen.getByRole('tab', { name: /Bulk/i });
rtl.fireEvent.click(bulkTab);
// Wait for session to be selected
await rtl.screen.findByRole('option', { name: /Primary Session/ });
// Enter phone number
const textarea = rtl.screen.getByPlaceholderText(/9612345678/i);
rtl.fireEvent.change(textarea, { target: { value: '919999999999' } });
// Start batch
const startBtn = rtl.screen.getByRole('button', { name: /Start Batch Check/i });
rtl.fireEvent.click(startBtn);
// Verify row displays Failed status and the error message
const failedBadge = await rtl.screen.findByText('Failed', { selector: '.nc-status-badge' });
assert.ok(failedBadge);
assert.ok(rtl.screen.getByText('Rate limit exceeded (HTTP 429)'));
// Verify "Not Registered" count is 0 and "Failed" count is 1
const notRegBox = rtl.screen.getByText('Not Registered').parentElement;
assert.ok(notRegBox?.textContent?.includes('0'));
const failedBox = rtl.screen.getByText('Failed', { selector: '.nc-stat-label' }).parentElement;
assert.ok(failedBox?.textContent?.includes('1'));
// Export CSV and verify Error status is retained
const exportBtn = rtl.screen.getByRole('button', { name: /Export Results/i });
rtl.fireEvent.click(exportBtn);
assert.equal(recordedDownloads.length, 1);
const csvContent = await recordedDownloads[0].text();
assert.ok(csvContent.includes('919999999999,Error,,Rate limit exceeded (HTTP 429),'));
assert.ok(!csvContent.includes('919999999999,No,'));
} finally {
URL.createObjectURL = realCreateObjectURL;
}
});
test('NumberChecker: Stop followed by Start while lookup is pending cancels earlier run and prevents overwriting', async () => {
let resolveFirstLookup!: (res: Response) => void;
const firstLookupPromise = new Promise<Response>(resolve => {
resolveFirstLookup = resolve;
});
globalThis.fetch = ((input: RequestInfo | URL) => {
const url = String(input);
if (url.includes('/contacts/check/911111111111')) {
return firstLookupPromise;
}
if (url.includes('/contacts/check/912222222222')) {
return Promise.resolve(jsonResponse({ number: '912222222222', exists: true, whatsappId: '[email protected]' }));
}
return Promise.resolve(
jsonResponse([
{
id: 'test-session-1',
name: 'Primary Session',
status: 'ready',
phone: '919876543210',
},
]),
);
}) as typeof fetch;
renderComponent();
// Switch to bulk tab
const bulkTab = rtl.screen.getByRole('tab', { name: /Bulk/i });
rtl.fireEvent.click(bulkTab);
await rtl.screen.findByRole('option', { name: /Primary Session/ });
const textarea = rtl.screen.getByPlaceholderText(/9612345678/i);
// Run 1: Start checking 911111111111
rtl.fireEvent.change(textarea, { target: { value: '911111111111' } });
const startBtn = rtl.screen.getByRole('button', { name: /Start Batch Check/i });
rtl.fireEvent.click(startBtn);
// Stop while lookup 1 is pending
const stopBtn = await rtl.screen.findByRole('button', { name: /Stop Checking/i });
rtl.fireEvent.click(stopBtn);
// Run 2: Start checking 912222222222
rtl.fireEvent.change(textarea, { target: { value: '912222222222' } });
const startBtnAgain = await rtl.screen.findByRole('button', { name: /Start Batch Check/i });
rtl.fireEvent.click(startBtnAgain);
// Late resolution of Run 1's pending lookup
resolveFirstLookup(jsonResponse({ number: '911111111111', exists: false, whatsappId: null }));
// Wait for Run 2 to finish
const registeredRow = await rtl.screen.findByText('+912222222222');
assert.ok(registeredRow);
// Ensure Run 1's late resolution did NOT overwrite or get appended to Run 2's results
assert.equal(rtl.screen.queryByText('+911111111111'), null);
const checkedBox = rtl.screen.getByText('Checked', { selector: '.nc-stat-label' }).parentElement;
assert.ok(checkedBox?.textContent?.includes('1'));
const regBox = rtl.screen.getByText('Registered', { selector: '.nc-stat-label' }).parentElement;
assert.ok(regBox?.textContent?.includes('1'));
});
const THREE_NUMBERS = '911111111111\n912222222222\n913333333333';
const startBatch = () => rtl.fireEvent.click(rtl.screen.getByRole('button', { name: /Start Batch Check/i }));
// Past the one-second pacing delay, which is when a run that went on would send its next lookup.
const pastPacing = () => new Promise(resolve => setTimeout(resolve, 1_200));
test('NumberChecker: signing out ends a running batch', async () => {
const lookups = stubLookups(registered);
// The providers are unmounted with the signed-in tree on a logout.
const { unmount } = renderComponent();
rtl.fireEvent.change(await openBulkTab(), { target: { value: THREE_NUMBERS } });
startBatch();
await rtl.waitFor(() => assert.equal(lookups.length, 1));
unmount();
await pastPacing();
assert.deepEqual(lookups, ['911111111111']);
});
test('NumberChecker: leaving the page keeps the run going and the rows are there on return', async () => {
let finishThird!: (res: Response) => void;
const third = new Promise<Response>(resolve => {
finishThird = resolve;
});
const lookups: string[] = [];
globalThis.fetch = ((input: RequestInfo | URL) => {
const url = String(input);
if (!url.includes('/contacts/check/')) return defaultFetch(input);
const number = url.split('/contacts/check/')[1];
lookups.push(number);
return number === '913333333333' ? third : Promise.resolve(registered(number));
}) as typeof fetch;
renderRoutes();
rtl.fireEvent.change(await openBulkTab(), { target: { value: THREE_NUMBERS } });
startBatch();
await rtl.waitFor(() => assert.equal(lookups.length, 1));
rtl.fireEvent.click(rtl.screen.getByText('Leave'));
assert.ok(rtl.screen.getByText('Elsewhere'));
assert.equal(document.querySelector('.number-checker') === null, true);
// The run goes on without the page: the second lookup is sent after the pacing delay, the third waits on its answer.
await rtl.waitFor(() => assert.equal(lookups.length, 3), { timeout: 5_000 });
rtl.fireEvent.click(rtl.screen.getByText('Return'));
// The Bulk tab is the one open, with the run in it: progress, the two rows so far, and Stop.
assert.equal(rtl.screen.getByRole('tab', { name: /Bulk/i }).getAttribute('aria-selected'), 'true');
assert.equal(rtl.screen.getByRole('progressbar').getAttribute('aria-valuenow'), '2');
assert.equal(statValue('Checked'), '2');
assert.ok(rtl.screen.getByText('+911111111111'));
assert.ok(rtl.screen.getByText('+912222222222'));
assert.ok(rtl.screen.getByRole('button', { name: /Stop Checking/i }));
// What the run was started with is in the form, which is locked meanwhile.
const textarea = rtl.screen.getByRole('textbox', { name: /Numbers/i }) as HTMLTextAreaElement;
assert.equal(textarea.value, THREE_NUMBERS);
assert.equal(textarea.disabled, true);
// It ends while the page is away: the toast comes from the provider, and the rows are there to export on return.
rtl.fireEvent.click(rtl.screen.getByText('Leave'));
finishThird(registered('913333333333'));
await rtl.screen.findByText('Completed checking 3 numbers.');
rtl.fireEvent.click(rtl.screen.getByText('Return'));
assert.equal(statValue('Checked'), '3');
assert.ok(rtl.screen.getByText('+913333333333'));
assert.ok(rtl.screen.getByRole('button', { name: /Export Results/i }));
assert.equal(rtl.screen.queryByRole('button', { name: /Stop Checking/i }), null);
});
test('NumberChecker: Stop from a page opened again ends the run that was started on the page before', async () => {
const lookups = stubLookups(registered);
renderRoutes();
rtl.fireEvent.change(await openBulkTab(), { target: { value: THREE_NUMBERS } });
startBatch();
await rtl.waitFor(() => assert.equal(lookups.length, 1));
rtl.fireEvent.click(rtl.screen.getByText('Leave'));
rtl.fireEvent.click(rtl.screen.getByText('Return'));
rtl.fireEvent.click(await rtl.screen.findByRole('button', { name: /Stop Checking/i }));
await pastPacing();
assert.deepEqual(lookups, ['911111111111']);
assert.equal(statValue('Checked'), '1');
});
test('NumberChecker: a second Start while a run is going is refused', async () => {
const lookups = stubLookups(registered);
function StartTwice() {
const run = useNumberCheck();
const twice = () => {
void run.start(['911111111111'], 'test-session-1', 0);
void run.start(['912222222222'], 'test-session-1', 0);
};
return createElement('button', { onClick: twice }, 'Start twice');
}
rtl.render(createElement(ToastProvider, null, createElement(NumberCheckProvider, null, createElement(StartTwice))));
rtl.fireEvent.click(rtl.screen.getByText('Start twice'));
await pastPacing();
assert.deepEqual(lookups, ['911111111111']);
});
test('NumberChecker: Stop ends the run, so no further lookup is sent', async () => {
const lookups = stubLookups(registered);
renderComponent();
rtl.fireEvent.change(await openBulkTab(), { target: { value: THREE_NUMBERS } });
startBatch();
await rtl.waitFor(() => assert.equal(lookups.length, 1));
rtl.fireEvent.click(await rtl.screen.findByRole('button', { name: /Stop Checking/i }));
await pastPacing();
assert.deepEqual(lookups, ['911111111111']);
assert.ok(rtl.screen.getByRole('button', { name: /Start Batch Check/i }));
});
test('NumberChecker: a lookup of an abandoned run that fails late adds no row to the next run', async () => {
let failFirst!: () => void;
const firstLookup = new Promise<Response>((_, reject) => {
failFirst = () => reject(new TypeError('Failed to fetch'));
});
globalThis.fetch = ((input: RequestInfo | URL) => {
const url = String(input);
if (url.includes('/contacts/check/911111111111')) return firstLookup;
if (url.includes('/contacts/check/')) return Promise.resolve(registered(url.split('/contacts/check/')[1]));
return defaultFetch(input);
}) as typeof fetch;
renderComponent();
const textarea = await openBulkTab();
rtl.fireEvent.change(textarea, { target: { value: '911111111111' } });
startBatch();
rtl.fireEvent.click(await rtl.screen.findByRole('button', { name: /Stop Checking/i }));
rtl.fireEvent.change(textarea, { target: { value: '912222222222' } });
startBatch();
await rtl.screen.findByText('+912222222222');
failFirst();
await new Promise(resolve => setTimeout(resolve, 50));
assert.equal(rtl.screen.queryByText('Failed', { selector: '.nc-status-badge' }) === null, true);
assert.ok(rtl.screen.getByText('+912222222222'));
assert.equal(statValue('Checked'), '1');
});
test('NumberChecker: the +91 rule is off by default in both tabs and the hints say numbers are checked as typed', async () => {
renderComponent();
await rtl.screen.findByRole('option', { name: /Primary Session/ });
assert.equal((rtl.screen.getByRole('checkbox') as HTMLInputElement).checked, false);
assert.ok(rtl.screen.getByText(/checked as typed/));
const textarea = await openBulkTab();
const box = rtl.screen.getByRole('checkbox') as HTMLInputElement;
assert.equal(box.checked, false);
assert.ok(rtl.screen.getByText(/checked as typed/));
rtl.fireEvent.change(textarea, { target: { value: '08123456789\n4155552671' } });
assert.equal(rtl.screen.queryByText(/ten-digit/), null);
rtl.fireEvent.click(box);
assert.match(rtl.screen.getByText(/ten-digit/).textContent ?? '', /2 ten-digit/);
assert.equal(rtl.screen.queryByText(/checked as typed/), null);
});
test('NumberChecker: a bulk run looks numbers up as typed by default', async () => {
const lookups = stubLookups(number => jsonResponse({ number, exists: false, whatsappId: null }));
renderComponent();
const textarea = await openBulkTab();
rtl.fireEvent.change(textarea, { target: { value: '08123456789\n4155552671' } });
rtl.fireEvent.click(rtl.screen.getByRole('button', { name: /Start Batch Check/i }));
await rtl.screen.findByText('Completed checking 2 numbers.', {}, { timeout: 3000 });
assert.deepEqual(lookups, ['08123456789', '4155552671']);
});
test('NumberChecker: the pacing delay starts at one second and offers nothing faster', async () => {
renderComponent();
await openBulkTab();
const select = rtl.screen.getByLabelText('Safe Pacing Delay (ms)') as HTMLSelectElement;
assert.equal(select.value, '1000');
assert.deepEqual(
[...select.options].map(option => option.value),
['1000', '2000', '3000'],
);
});
test('NumberChecker: a list over the per-run limit blocks Start and names the limit and the count', async () => {
stubLookups(registered);
const { container } = renderComponent();
const textarea = await openBulkTab();
const list = (count: number) =>
Array.from({ length: count }, (_, i) => `628120${String(i).padStart(6, '0')}`).join('\n');
const start = () => rtl.screen.getByRole('button', { name: /Start Batch Check/i }) as HTMLButtonElement;
rtl.fireEvent.change(textarea, { target: { value: list(NUMBER_CHECK_BATCH_MAX) } });
assert.equal(start().disabled, false);
assert.equal(container.querySelector('.nc-batch-limit'), null);
rtl.fireEvent.change(textarea, { target: { value: list(NUMBER_CHECK_BATCH_MAX + 1) } });
assert.equal(start().disabled, true);
const message = container.querySelector('.nc-batch-limit')?.textContent ?? '';
assert.match(message, new RegExp(`${NUMBER_CHECK_BATCH_MAX + 1} parsed`));
assert.match(message, new RegExp(`at most ${NUMBER_CHECK_BATCH_MAX} per run`));
// Repeats collapse before the limit applies.
rtl.fireEvent.change(textarea, { target: { value: `${list(NUMBER_CHECK_BATCH_MAX)}\n${list(5)}` } });
assert.equal(start().disabled, false);
assert.equal(container.querySelector('.nc-batch-limit'), null);
});
const twoSessions = (betaStatus: string) => [
{ id: 'sess-a', name: 'Alpha', status: 'ready', phone: '111' },
{ id: 'sess-b', name: 'Beta', status: betaStatus, phone: '222' },
];
test('NumberChecker: a chosen session that leaves the ready list is replaced by the one the select then shows', async () => {
const checked: string[] = [];
globalThis.fetch = ((input: RequestInfo | URL) => {
const url = String(input);
if (url.includes('/contacts/check/')) {
checked.push(url);
return Promise.resolve(jsonResponse({ number: '919876543210', exists: false, whatsappId: null }));
}
return Promise.resolve(jsonResponse(twoSessions('ready')));
}) as typeof fetch;
const client = createTestQueryClient();
renderComponent('operator', client);
await rtl.screen.findByRole('option', { name: /Beta/ });
const select = rtl.screen.getByRole('combobox', { name: 'WhatsApp Session' }) as HTMLSelectElement;
rtl.fireEvent.change(select, { target: { value: 'sess-b' } });
assert.equal(select.value, 'sess-b');
await rtl.act(async () => client.setQueryData(['sessions'], twoSessions('disconnected')));
// Only Alpha is left to show, so Alpha is the session the lookup has to use.
await rtl.waitFor(() => assert.equal(rtl.screen.queryByRole('option', { name: /Beta/ }) === null, true));
assert.deepEqual(
[...select.options].map(option => option.value),
['sess-a'],
);
rtl.fireEvent.change(rtl.screen.getByPlaceholderText(/9876543210/), { target: { value: '919876543210' } });
rtl.fireEvent.click(rtl.screen.getByRole('button', { name: 'Check' }));
await rtl.screen.findByText('Not Registered', { selector: '.nc-status-badge' });
assert.equal(checked.length, 1);
assert.match(checked[0], /\/sessions\/sess-a\/contacts\/check\//);
});
// The select is locked during a run, so what it shows has to stay the session the run uses, whatever the ready list does.
test('NumberChecker: a locked select keeps naming the run session when the chosen session drops out and returns', async () => {
const checked: string[] = [];
const pictures: string[] = [];
globalThis.fetch = ((input: RequestInfo | URL) => {
const url = String(input);
if (url.includes('/profile-picture')) {
pictures.push(url);
return Promise.resolve(jsonResponse({ url: null }));
}
if (url.includes('/contacts/check/')) {
checked.push(url);
return url.endsWith('/919999999999')
? Promise.resolve(registered('919999999999'))
: new Promise<Response>(() => {});
}
return Promise.resolve(jsonResponse(twoSessions('ready')));
}) as typeof fetch;
const client = createTestQueryClient();
renderComponent('operator', client);
await rtl.screen.findByRole('option', { name: /Beta/ });
const select = () => rtl.screen.getByRole('combobox', { name: 'WhatsApp Session' }) as HTMLSelectElement;
const options = () => [...select().options].map(option => option.value);
// Beta is chosen, drops out (the select falls back to Alpha), and the run starts on Alpha.
rtl.fireEvent.change(select(), { target: { value: 'sess-b' } });
await rtl.act(async () => client.setQueryData(['sessions'], twoSessions('disconnected')));
await rtl.waitFor(() => assert.deepEqual(options(), ['sess-a']));
rtl.fireEvent.click(rtl.screen.getByRole('tab', { name: /Bulk/i }));
rtl.fireEvent.change(rtl.screen.getByPlaceholderText(/9612345678/i), { target: { value: THREE_NUMBERS } });
startBatch();
await rtl.waitFor(() => assert.equal(checked.length, 1));
assert.match(checked[0], /\/sessions\/sess-a\//);
// Beta returns while the run is going: the select still names the session the lookups go to.
await rtl.act(async () => client.setQueryData(['sessions'], twoSessions('ready')));
await rtl.waitFor(() => assert.deepEqual(options(), ['sess-a', 'sess-b']));
assert.equal(select().value, 'sess-a');
assert.equal(select().disabled, true);
// A single check made meanwhile goes to the session the select shows too.
rtl.fireEvent.click(rtl.screen.getByRole('tab', { name: /Single Check/i }));
assert.equal(select().value, 'sess-a');
rtl.fireEvent.change(rtl.screen.getByPlaceholderText(/9876543210/), { target: { value: '919999999999' } });
rtl.fireEvent.click(rtl.screen.getByRole('button', { name: 'Check' }));
await rtl.waitFor(() => assert.equal(checked.length, 2));
assert.match(checked[1], /\/sessions\/sess-a\/contacts\/check\/919999999999/);
// The avatar request belongs to that lookup, so it goes to the same session.
await rtl.waitFor(() => assert.equal(pictures.length, 1));
assert.match(pictures[0], /\/sessions\/sess-a\/contacts\//);
});
test('NumberChecker: the session cannot be switched from the Single tab while a bulk run is going', async () => {
globalThis.fetch = ((input: RequestInfo | URL) => {
if (String(input).includes('/contacts/check/')) return new Promise<Response>(() => {});
return Promise.resolve(jsonResponse(twoSessions('ready')));
}) as typeof fetch;
renderComponent();
rtl.fireEvent.click(rtl.screen.getByRole('tab', { name: /Bulk/i }));
await rtl.screen.findByRole('option', { name: /Beta/ });
rtl.fireEvent.change(rtl.screen.getByPlaceholderText(/9612345678/i), { target: { value: THREE_NUMBERS } });
startBatch();
await rtl.screen.findByRole('button', { name: /Stop Checking/i });
rtl.fireEvent.click(rtl.screen.getByRole('tab', { name: /Single Check/i }));
const select = rtl.screen.getByRole('combobox', { name: 'WhatsApp Session' }) as HTMLSelectElement;
assert.equal(select.disabled, true);
});
const statValue = (label: string) =>
rtl.screen.getByText(label, { selector: '.nc-stat-label' }).parentElement?.querySelector('.nc-stat-number')
?.textContent;
test('NumberChecker: a gateway refusal stops the batch and the numbers never reached get no rows', async () => {
const lookups = stubLookups(number =>
number === '912222222222' ? jsonResponse({ message: 'Rate limit exceeded (HTTP 429)' }, 429) : registered(number),
);
const { container } = renderComponent();
const textarea = await openBulkTab();
rtl.fireEvent.change(textarea, { target: { value: '911111111111\n912222222222\n913333333333\n914444444444' } });
rtl.fireEvent.click(rtl.screen.getByRole('button', { name: /Start Batch Check/i }));
await rtl.screen.findByText('Batch stopped', { selector: 'strong' }, { timeout: 3000 });
const notice = container.querySelector('.nc-batch-stopped')?.textContent ?? '';
assert.match(notice, /The gateway rate limit was reached \(HTTP 429\)/);
assert.match(notice, /Stopped at number 2 of 4; 2 numbers were not sent/);
// The refused lookup is a failed row; the two numbers behind it were never sent, so they have none.
assert.ok(rtl.screen.getByText('+911111111111'));
assert.ok(rtl.screen.getByText('Rate limit exceeded (HTTP 429)'));
assert.equal(rtl.screen.queryByText('+913333333333'), null);
assert.equal(rtl.screen.queryByText('+914444444444'), null);
assert.equal(statValue('Checked'), '2');
assert.equal(statValue('Failed'), '1');
assert.equal(statValue('Remaining'), '2');
assert.equal(rtl.screen.queryByText(/Completed checking/), null);
assert.equal((rtl.screen.getByRole('button', { name: /Start Batch Check/i }) as HTMLButtonElement).disabled, false);
// Past the pacing delay, which is when a run that went on would have looked up the third number.
await new Promise(resolve => setTimeout(resolve, 1_200));
assert.deepEqual(lookups, ['911111111111', '912222222222']);
});
const STOP_REASON: Record<number, RegExp> = {
400: /The session is not connected \(HTTP 400\)/,
502: /The gateway refused a lookup \(HTTP 502\)/,
409: /The session is not connected \(HTTP 409\)/,
429: /The gateway rate limit was reached \(HTTP 429\)/,
503: /WhatsApp did not answer a lookup \(HTTP 503\)/,
};
for (const status of [400, 409, 429, 502, 503]) {
test(`NumberChecker: HTTP ${status} on the first lookup stops the batch before the second`, async () => {
const lookups = stubLookups(() =>
jsonResponse({ message: status === 400 ? 'Session is not started' : `refused ${status}` }, status),
);
const { container } = renderComponent();
const textarea = await openBulkTab();
rtl.fireEvent.change(textarea, { target: { value: '911111111111\n912222222222' } });
rtl.fireEvent.click(rtl.screen.getByRole('button', { name: /Start Batch Check/i }));
await rtl.screen.findByText('Batch stopped', { selector: 'strong' });
const notice = container.querySelector('.nc-batch-stopped')?.textContent ?? '';
assert.match(notice, STOP_REASON[status]);
// Number 1 was sent and refused, so only number 2 was never sent.
assert.match(notice, /Stopped at number 1 of 2; 1 number was not sent/);
assert.deepEqual(lookups, ['911111111111']);
assert.equal(rtl.screen.queryByText(/Completed checking/), null);
});
}
// The route is closed to the key as a whole (a key limited to chats reaches no number check), so every later number
// would be refused alike and each refusal is a failed-authentication row in the gateway's audit log.
test('NumberChecker: HTTP 403 on the first lookup stops the batch before the second', async () => {
const lookups = stubLookups(() => jsonResponse({ message: 'API key is restricted to selected chats' }, 403));
const { container } = renderComponent();
const textarea = await openBulkTab();
rtl.fireEvent.change(textarea, { target: { value: '911111111111\n912222222222' } });
rtl.fireEvent.click(rtl.screen.getByRole('button', { name: /Start Batch Check/i }));
await rtl.screen.findByText('Batch stopped', { selector: 'strong' });
const notice = container.querySelector('.nc-batch-stopped')?.textContent ?? '';
assert.match(notice, /The gateway refused a lookup \(HTTP 403\)/);
assert.match(notice, /Stopped at number 1 of 2; 1 number was not sent/);
assert.deepEqual(lookups, ['911111111111']);
assert.equal(rtl.screen.queryByText(/Completed checking/), null);
});
test('NumberChecker: a lookup that gets no answer at all stops the batch before the second', async () => {
const lookups: string[] = [];
globalThis.fetch = ((input: RequestInfo | URL) => {
const url = String(input);
if (url.includes('/contacts/check/')) {
lookups.push(url.split('/contacts/check/')[1]);
return Promise.reject(new TypeError('Failed to fetch'));
}
return defaultFetch(input);
}) as typeof fetch;
const { container } = renderComponent();
const textarea = await openBulkTab();
rtl.fireEvent.change(textarea, { target: { value: '911111111111\n912222222222' } });
rtl.fireEvent.click(rtl.screen.getByRole('button', { name: /Start Batch Check/i }));
await rtl.screen.findByText('Batch stopped', { selector: 'strong' });
const notice = container.querySelector('.nc-batch-stopped')?.textContent ?? '';
assert.match(notice, /The gateway did not answer\. Stopped at number 1 of 2\./);
assert.deepEqual(lookups, ['911111111111']);
assert.equal(rtl.screen.queryByText(/Completed checking/), null);
});
// Only a fetch that gets no answer ends the run. A 200 whose body cannot be read is that lookup's failure.
test('NumberChecker: an answer that is not JSON fails that number and the run goes on', async () => {
const lookups = stubLookups(number =>
number === '911111111111' ? new Response('<html>sign in</html>', { status: 200 }) : registered(number),
);
const { container } = renderComponent();
const textarea = await openBulkTab();
rtl.fireEvent.change(textarea, { target: { value: '911111111111\n912222222222' } });
startBatch();
await rtl.screen.findByText('Completed checking 2 numbers.', {}, { timeout: 3000 });
assert.deepEqual(lookups, ['911111111111', '912222222222']);
assert.equal(statValue('Failed'), '1');
assert.equal(container.querySelector('.nc-batch-stopped'), null);
});
// 400 ends a run only for a session that is not running; any other 400 is about that number.
test('NumberChecker: a 400 that is not about the session fails that number and the run goes on', async () => {
const lookups = stubLookups(number =>
number === '911111111111' ? jsonResponse({ message: 'Invalid number' }, 400) : registered(number),
);
const { container } = renderComponent();
const textarea = await openBulkTab();
rtl.fireEvent.change(textarea, { target: { value: '911111111111\n912222222222' } });
startBatch();
await rtl.screen.findByText('Completed checking 2 numbers.', {}, { timeout: 3000 });
assert.deepEqual(lookups, ['911111111111', '912222222222']);
assert.equal(statValue('Failed'), '1');
assert.equal(container.querySelector('.nc-batch-stopped'), null);
});
test('NumberChecker: a refusal on the last number says so instead of counting numbers left unsent', async () => {
const lookups = stubLookups(number =>
number === '912222222222' ? jsonResponse({ message: 'Rate limit exceeded (HTTP 429)' }, 429) : registered(number),
);
const { container } = renderComponent();
const textarea = await openBulkTab();
rtl.fireEvent.change(textarea, { target: { value: '911111111111\n912222222222' } });
rtl.fireEvent.click(rtl.screen.getByRole('button', { name: /Start Batch Check/i }));
await rtl.screen.findByText('Batch stopped', { selector: 'strong' }, { timeout: 3000 });
const notice = container.querySelector('.nc-batch-stopped')?.textContent ?? '';
assert.match(notice, /The last lookup failed/);
assert.doesNotMatch(notice, /not sent/);
assert.deepEqual(lookups, ['911111111111', '912222222222']);
assert.equal(rtl.screen.queryByText(/Completed checking/), null);
});
test('NumberChecker: a lookup error that is not a gateway refusal fails that number and the run goes on', async () => {
const lookups = stubLookups(number =>
number === '911111111111' ? jsonResponse({ message: 'engine hiccup' }, 500) : registered(number),
);
const { container } = renderComponent();
const textarea = await openBulkTab();
rtl.fireEvent.change(textarea, { target: { value: '911111111111\n912222222222' } });
rtl.fireEvent.click(rtl.screen.getByRole('button', { name: /Start Batch Check/i }));
await rtl.screen.findByText('Completed checking 2 numbers.', {}, { timeout: 3000 });
assert.deepEqual(lookups, ['911111111111', '912222222222']);
assert.ok(rtl.screen.getByText('engine hiccup'));
assert.ok(rtl.screen.getByText('+912222222222'));
assert.equal(statValue('Failed'), '1');
assert.equal(container.querySelector('.nc-batch-stopped'), null);
});
test('NumberChecker: a new run starts on the All filter, so a Failed filter left over does not hide its rows', async () => {
stubLookups(number =>
number === '911111111111' ? jsonResponse({ message: 'engine hiccup' }, 500) : registered(number),
);
const { container } = renderComponent();
const textarea = await openBulkTab();
rtl.fireEvent.change(textarea, { target: { value: '911111111111' } });
rtl.fireEvent.click(rtl.screen.getByRole('button', { name: /Start Batch Check/i }));
rtl.fireEvent.click(await rtl.screen.findByRole('button', { name: /^Failed \(1\)/ }));
rtl.fireEvent.change(textarea, { target: { value: '912222222222' } });
rtl.fireEvent.click(rtl.screen.getByRole('button', { name: /Start Batch Check/i }));
await rtl.screen.findByText('+912222222222');
assert.match(container.querySelector('.nc-filter-btn.active')?.textContent ?? '', /^All \(1\)/);
});
test('NumberChecker: a run in which every lookup failed is not reported as completed', async () => {
const lookups = stubLookups(() => jsonResponse({ message: 'engine hiccup' }, 500));
const { container } = renderComponent();
const textarea = await openBulkTab();
rtl.fireEvent.change(textarea, { target: { value: '911111111111\n912222222222' } });
rtl.fireEvent.click(rtl.screen.getByRole('button', { name: /Start Batch Check/i }));
await rtl.screen.findByText('Check failed', {}, { timeout: 3000 });
assert.deepEqual(lookups, ['911111111111', '912222222222']);
assert.equal(statValue('Failed'), '2');
assert.equal(rtl.screen.queryByText(/Completed checking/), null);
assert.equal(container.querySelector('.nc-batch-stopped'), null);
});
// The Clipboard API is missing over plain HTTP on a LAN address, where the Copy button used to throw
// before it could report anything. The house helper falls back to the textarea route.
test('NumberChecker: Copy works where navigator.clipboard does not exist', async t => {
stubLookups(registered);
const copy = t.mock.fn(() => true);
const hadExecCommand = Object.getOwnPropertyDescriptor(document, 'execCommand');
Object.defineProperty(document, 'execCommand', { value: copy, configurable: true, writable: true });
t.after(() => {
if (hadExecCommand) Object.defineProperty(document, 'execCommand', hadExecCommand);
else delete (document as unknown as Record<string, unknown>).execCommand;
});
assert.equal(navigator.clipboard, undefined);
renderComponent();
await rtl.screen.findByRole('option', { name: /Primary Session/ });
rtl.fireEvent.change(rtl.screen.getByPlaceholderText(/9876543210/), { target: { value: '919876543210' } });
rtl.fireEvent.click(rtl.screen.getByRole('button', { name: 'Check' }));
await rtl.screen.findByText('Registered', { selector: '.nc-status-badge' });
rtl.fireEvent.click(rtl.screen.getByRole('button', { name: /^Copy$/ }));
await rtl.screen.findByRole('button', { name: /Copied/ });
assert.equal(copy.mock.callCount(), 1);
assert.deepEqual(copy.mock.calls[0].arguments, ['copy']);
});
function heldSingleResponse() {
let release!: (response: Response) => void;
const promise = new Promise<Response>(resolve => (release = resolve));
return { promise, release };
}
async function finishSingleResponse(pending: ReturnType<typeof heldSingleResponse>, response: Response) {
await rtl.act(async () => {
pending.release(response);
await pending.promise;
await new Promise<void>(resolve => setImmediate(resolve));
});
}
async function startSingleLookup(number = '6581234567') {
await rtl.screen.findByRole('option', { name: /Primary Session/ });
rtl.fireEvent.change(rtl.screen.getByPlaceholderText(/9876543210/), { target: { value: number } });
rtl.fireEvent.click(rtl.screen.getByRole('button', { name: 'Check' }));
}
const SINGLE_KEY_A = 'dummy-single-key-a';
const SINGLE_KEY_B = 'dummy-single-key-b';
type SingleRetirement = 'route' | 'key-change' | 'logout-login';
async function retireSingleLookup(reason: SingleRetirement) {
if (reason === 'route') {
rtl.fireEvent.click(rtl.screen.getByText('Leave'));
await rtl.screen.findByText('Elsewhere');
} else if (reason === 'key-change') {
sessionStorage.setItem('openwa_api_key', SINGLE_KEY_B);
} else {
sessionStorage.removeItem('openwa_api_key');
rtl.cleanup();
sessionStorage.setItem('openwa_api_key', SINGLE_KEY_B);
renderRoutes();
await rtl.screen.findByRole('option', { name: /Primary Session/ });
}
}
for (const reason of ['route', 'key-change', 'logout-login'] as const) {
for (const answer of ['registered', 'missing', 'failure'] as const) {
test(`NumberChecker: a single lookup retired by ${reason} ignores its late ${answer} response`, async () => {
const pending = heldSingleResponse();
const checks: { path: string; key: string | null }[] = [];
const pictures: { path: string; key: string | null }[] = [];
globalThis.fetch = ((input: RequestInfo | URL, init?: RequestInit) => {
const path = String(input);
const key = new Headers(init?.headers).get('X-API-Key');
if (path.includes('/contacts/check/')) {
checks.push({ path, key });
return pending.promise;
}
if (path.includes('/profile-picture')) {
pictures.push({ path, key });
return Promise.resolve(jsonResponse({ url: 'https://avatar.invalid/retired.png' }));
}
return defaultFetch(input, init);
}) as typeof fetch;
sessionStorage.setItem('openwa_api_key', SINGLE_KEY_A);
renderRoutes();
await startSingleLookup();
assert.deepEqual(checks, [
{
path: '/api/sessions/test-session-1/contacts/check/6581234567',
key: SINGLE_KEY_A,
},
]);
await retireSingleLookup(reason);
const response =
answer === 'failure'
? jsonResponse({ message: 'Retired single lookup failed' }, 503)
: jsonResponse({
number: '6581234567',
exists: answer === 'registered',
whatsappId: answer === 'registered' ? '[email protected]' : null,
});
await finishSingleResponse(pending, response);
assert.deepEqual(pictures, [], 'a retired lookup dispatched an optional profile request');
assert.equal(document.querySelector('.nc-result-card') === null, true, 'a retired lookup published a result');
assert.equal(
document.querySelector('.nc-history-table tbody tr') === null,
true,
'a retired lookup added recent history',
);
assert.equal(document.querySelector('.toast') === null, true, 'a retired lookup published a toast');
if (reason === 'route') {
rtl.fireEvent.click(rtl.screen.getByText('Return'));
await rtl.screen.findByRole('option', { name: /Primary Session/ });
assert.equal(document.querySelector('.nc-result-card') === null, true);
}
});
}
for (const answer of ['avatar', 'failure'] as const) {
test(`NumberChecker: a profile lookup retired by ${reason} ignores its late ${answer} response`, async () => {
const pending = heldSingleResponse();
const pictures: { path: string; key: string | null }[] = [];
globalThis.fetch = ((input: RequestInfo | URL, init?: RequestInit) => {
const path = String(input);
if (path.includes('/contacts/check/')) return Promise.resolve(registered('6581234567'));
if (path.includes('/profile-picture')) {
pictures.push({ path, key: new Headers(init?.headers).get('X-API-Key') });
return pending.promise;
}
return defaultFetch(input, init);
}) as typeof fetch;
sessionStorage.setItem('openwa_api_key', SINGLE_KEY_A);
renderRoutes();
await startSingleLookup();
await rtl.waitFor(() =>
assert.deepEqual(pictures, [
{
path: '/api/sessions/test-session-1/contacts/6581234567%40c.us/profile-picture',
key: SINGLE_KEY_A,
},
]),
);
await retireSingleLookup(reason);
await finishSingleResponse(
pending,
answer === 'avatar'
? jsonResponse({ url: 'https://avatar.invalid/retired.png' })
: jsonResponse({ message: 'Retired profile lookup failed' }, 500),
);
assert.equal(pictures.length, 1);
assert.equal(
document.querySelector('.nc-result-card') === null,
true,
'a retired profile lookup published a result',
);
assert.equal(
document.querySelector('.nc-history-table tbody tr') === null,
true,
'a retired profile lookup added history',
);
assert.equal(document.querySelector('.toast') === null, true, 'a retired profile lookup published a toast');
});
}
}
for (const answer of ['avatar', 'no-avatar', 'profile-failure', 'missing'] as const) {
test(`NumberChecker: an active single lookup keeps its ${answer} result`, async () => {
const pictures: { path: string; key: string | null }[] = [];
globalThis.fetch = ((input: RequestInfo | URL, init?: RequestInit) => {
const path = String(input);
if (path.includes('/contacts/check/')) {
return Promise.resolve(
answer === 'missing'
? jsonResponse({ number: '6581234567', exists: false, whatsappId: null })
: registered('6581234567'),
);
}
if (path.includes('/profile-picture')) {
pictures.push({ path, key: new Headers(init?.headers).get('X-API-Key') });
return Promise.resolve(
answer === 'profile-failure'
? jsonResponse({ message: 'Optional avatar unavailable' }, 500)
: jsonResponse({ url: answer === 'avatar' ? 'https://avatar.invalid/current.png' : null }),
);
}
return defaultFetch(input, init);
}) as typeof fetch;
sessionStorage.setItem('openwa_api_key', SINGLE_KEY_A);
renderComponent();
await startSingleLookup();
await rtl.screen.findByText(answer === 'missing' ? 'Not Registered' : 'Registered on WhatsApp', {
selector: '.nc-status-badge',
});
assert.equal(document.querySelector('.nc-result-phone')?.textContent, '+6581234567');
assert.equal(
document.querySelector('.nc-avatar')?.getAttribute('src') ?? null,
answer === 'avatar' ? 'https://avatar.invalid/current.png' : null,
);
assert.deepEqual(
pictures,
answer === 'missing'
? []
: [
{
path: '/api/sessions/test-session-1/contacts/6581234567%40c.us/profile-picture',
key: SINGLE_KEY_A,
},
],
);
assert.equal(document.querySelector('.toast') === null, true);
assert.equal((rtl.screen.getByRole('button', { name: 'Check' }) as HTMLButtonElement).disabled, false);
});
}
test('NumberChecker: an active single lookup reports a failure and permits retry', async () => {
let fail = true;
const pictures: string[] = [];
globalThis.fetch = ((input: RequestInfo | URL, init?: RequestInit) => {
const path = String(input);
if (path.includes('/contacts/check/')) {
return Promise.resolve(
fail
? jsonResponse({ message: 'Current single lookup failed' }, 503)
: jsonResponse({ number: '6581234567', exists: false, whatsappId: null }),
);
}
if (path.includes('/profile-picture')) pictures.push(path);
return defaultFetch(input, init);
}) as typeof fetch;
renderComponent();
await startSingleLookup();
await rtl.screen.findByText('Current single lookup failed');
assert.equal(document.querySelector('.nc-result-card') === null, true);
assert.equal((rtl.screen.getByRole('button', { name: 'Check' }) as HTMLButtonElement).disabled, false);
fail = false;
rtl.fireEvent.click(rtl.screen.getByRole('button', { name: 'Check' }));
await rtl.screen.findByText('Not Registered', { selector: '.nc-status-badge' });
assert.deepEqual(pictures, []);
});
test('NumberChecker: single lookup history keeps ten recent distinct numbers', async () => {
globalThis.fetch = ((input: RequestInfo | URL, init?: RequestInit) => {
const path = String(input);
if (path.includes('/contacts/check/')) {
return Promise.resolve(
jsonResponse({ number: path.split('/contacts/check/')[1], exists: false, whatsappId: null }),
);
}
return defaultFetch(input, init);
}) as typeof fetch;
renderComponent();
const numbers = Array.from({ length: 11 }, (_, i) => `65812345${String(i).padStart(2, '0')}`);
for (const number of numbers) {
await startSingleLookup(number);
await rtl.waitFor(() => assert.equal(document.querySelector('.nc-result-phone')?.textContent, `+${number}`));
}
const history = () =>
[...document.querySelectorAll('.nc-history-table tbody tr')].map(row => row.children[0].textContent);
assert.deepEqual(
history(),
numbers
.slice(1)
.reverse()
.map(number => `+${number}`),
);
await startSingleLookup(numbers[4]);
await rtl.waitFor(() => assert.equal(document.querySelector('.nc-result-phone')?.textContent, `+${numbers[4]}`));
assert.deepEqual(
history(),
[
numbers[4],
...numbers
.slice(1)
.reverse()
.filter(number => number !== numbers[4]),
].map(number => `+${number}`),
);
});