Tests with node:test and node:assert

import assert from 'node:assert/strict';

// Throws an AssertionError when toCents breaks one of its rules.
export function checkToCents(toCents) {
  assert.equal(toCents('7'), 700, "toCents('7') should be 700");
  // Add the other rules: '3.50', '0.29' and 'abc'.
}

// A correct toCents passes the check.
checkToCents((text) => {
  if (!/^\d+(\.\d{1,2})?$/.test(text)) throw new RangeError('not a price: ' + text);
  return Math.round(Number(text) * 100);
});
console.log('the correct toCents passed');

import {test} from 'node:test';
import assert from 'node:assert/strict';
import {checkToCents} from './main.js';

// A correct toCents, and broken ones with one bug each.
const good = (text) => {
  if (!/^\d+(\.\d{1,2})?$/.test(text)) throw new RangeError('not a price: ' + text);
  return Math.round(Number(text) * 100);
};
const floors = (text) => (good(text), Math.floor(Number(text) * 100));
const strings = (text) => String(good(text));
const noThrow = (text) => (/^\d+(\.\d{1,2})?$/.test(text) ? good(text) : NaN);
const wrongError = (text) => {
  if (!/^\d+(\.\d{1,2})?$/.test(text)) throw new TypeError('not a price: ' + text);
  return good(text);
};
const catches = (broken) => {
  try {
    checkToCents(broken);
  } catch (error) {
    return error.name;
  }
  return 'nothing';
};

test('your check accepts a correct toCents', () => {
  checkToCents(good);
});

test('your check catches Math.floor, which turns 0.29 into 28', () => {
  assert.equal(catches(floors), 'AssertionError', 'checkToCents(floors) should throw an AssertionError');
});

test('your check catches a toCents that returns strings', () => {
  assert.equal(catches(strings), 'AssertionError', 'checkToCents(strings) should throw an AssertionError');
});

test('your check catches a toCents that returns NaN instead of throwing', () => {
  assert.equal(catches(noThrow), 'AssertionError', 'checkToCents(noThrow) should throw an AssertionError');
});

test('your check catches a toCents that throws a TypeError', () => {
  assert.equal(catches(wrongError), 'AssertionError', 'checkToCents(wrongError) should throw an AssertionError');
});

{
  "type": "module"
}

import assert from 'node:assert/strict';

// Rejects with an AssertionError when findUser breaks one of its rules.
export async function checkFindUser(findUser) {
  const user = await findUser(1);
  assert.equal(user.name, 'Ada', 'findUser(1) should be called Ada');
}

// A correct findUser passes the check.
const users = {1: 'Ada', 2: 'Lin'};
await checkFindUser(async (id) => {
  if (!(id in users)) throw new Error('no user ' + id);
  return {id, name: users[id]};
});
console.log('the correct findUser passed');

import {test} from 'node:test';
import assert from 'node:assert/strict';
import {checkFindUser} from './main.js';

// A correct findUser, and broken ones with one bug each.
const users = {1: 'Ada', 2: 'Lin'};
const good = async (id) => {
  if (!(id in users)) throw new Error('no user ' + id);
  return {id, name: users[id]};
};
const stringId = async (id) => ({...(await good(id)), id: String(id)});
const extraField = async (id) => ({...(await good(id)), admin: false});
const noReject = async (id) => (id in users ? good(id) : undefined);
const otherMessage = async (id) => {
  if (!(id in users)) throw new Error('not found');
  return good(id);
};
const catches = async (broken) => {
  try {
    await checkFindUser(broken);
  } catch (error) {
    return error.name;
  }
  return 'nothing';
};

test('your check accepts a correct findUser', async () => {
  await checkFindUser(good);
});

test('your check catches an id that is a string', async () => {
  assert.equal(await catches(stringId), 'AssertionError', 'checkFindUser(stringId) should reject with an AssertionError');
});

test('your check catches an extra field', async () => {
  assert.equal(await catches(extraField), 'AssertionError', 'checkFindUser(extraField) should reject with an AssertionError');
});

test('your check catches an unknown id that does not reject', async () => {
  assert.equal(await catches(noReject), 'AssertionError', 'checkFindUser(noReject) should reject with an AssertionError');
});

test('your check catches the wrong error message', async () => {
  assert.equal(await catches(otherMessage), 'AssertionError', 'checkFindUser(otherMessage) should reject with an AssertionError');
});

{
  "type": "module"
}