Tests mit node:test und 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('Ihre Prüfung akzeptiert ein korrektes toCents', () => {
  checkToCents(good);
});

test('Ihre Prüfung fängt Math.floor, das aus 0.29 28 macht', () => {
  assert.equal(catches(floors), 'AssertionError', 'checkToCents(floors) sollte einen AssertionError werfen');
});

test('Ihre Prüfung fängt ein toCents, das Strings liefert', () => {
  assert.equal(catches(strings), 'AssertionError', 'checkToCents(strings) sollte einen AssertionError werfen');
});

test('Ihre Prüfung fängt ein toCents, das NaN liefert, statt zu werfen', () => {
  assert.equal(catches(noThrow), 'AssertionError', 'checkToCents(noThrow) sollte einen AssertionError werfen');
});

test('Ihre Prüfung fängt ein toCents, das einen TypeError wirft', () => {
  assert.equal(catches(wrongError), 'AssertionError', 'checkToCents(wrongError) sollte einen AssertionError werfen');
});

{
  "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('Ihre Prüfung akzeptiert ein korrektes findUser', async () => {
  await checkFindUser(good);
});

test('Ihre Prüfung fängt eine id, die ein String ist', async () => {
  assert.equal(await catches(stringId), 'AssertionError', 'checkFindUser(stringId) sollte mit einem AssertionError ablehnen');
});

test('Ihre Prüfung fängt ein zusätzliches Feld', async () => {
  assert.equal(await catches(extraField), 'AssertionError', 'checkFindUser(extraField) sollte mit einem AssertionError ablehnen');
});

test('Ihre Prüfung fängt eine unbekannte id, die nicht ablehnt', async () => {
  assert.equal(await catches(noReject), 'AssertionError', 'checkFindUser(noReject) sollte mit einem AssertionError ablehnen');
});

test('Ihre Prüfung fängt die falsche Fehlermeldung', async () => {
  assert.equal(await catches(otherMessage), 'AssertionError', 'checkFindUser(otherMessage) sollte mit einem AssertionError ablehnen');
});

{
  "type": "module"
}