Build: ein Trinkgeldrechner für die Kommandozeile

// Step 1: the arithmetic. amount, tip (a percentage) and people are numbers.
// Return the tip, the total and each share, rounded to cents.
export function splitBill({amount, tip, people}) {
  return {tip: 0, total: amount, each: amount};
}

console.log(splitBill({amount: 60, tip: 15, people: 3}));

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

test('60 mit 15 % Trinkgeld für 3 Personen: tip 9, total 69, each 23', () => {
  const got = splitBill({amount: 60, tip: 15, people: 3});
  assert.deepEqual(got, {tip: 9, total: 69, each: 23}, `splitBill lieferte ${JSON.stringify(got)}`);
});

test('jeder Anteil wird auf Cent gerundet: 100 mit 10 % für 3 Personen ergibt je 36.67', () => {
  const got = splitBill({amount: 100, tip: 10, people: 3});
  assert.deepEqual(got, {tip: 10, total: 110, each: 36.67}, `splitBill lieferte ${JSON.stringify(got)}`);
});

test('das Trinkgeld wird auf Cent gerundet: 19.99 mit 15 % ergibt ein Trinkgeld von 3', () => {
  const got = splitBill({amount: 19.99, tip: 15, people: 1});
  assert.deepEqual(got, {tip: 3, total: 22.99, each: 22.99}, `splitBill lieferte ${JSON.stringify(got)}`);
});

test('0 % Trinkgeld: die Summe ist der Betrag', () => {
  const got = splitBill({amount: 80, tip: 0, people: 4});
  assert.deepEqual(got, {tip: 0, total: 80, each: 20}, `splitBill lieferte ${JSON.stringify(got)}`);
});

{
  "type": "module"
}

// Step 2: the values from the command line are strings. Convert them, and
// throw an Error naming the bad value if one cannot be used:
// amount above 0, tip from 0, people a whole number from 1.
export function toNumbers({amount, tip, people}) {
  return {amount: Number(amount), tip: Number(tip), people: Number(people)};
}

console.log(toNumbers({amount: "60", tip: "15", people: "3"}));

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

const ok = {amount: '60', tip: '15', people: '3'};

test('"60", "15" und "3" werden zu den Zahlen 60, 15 und 3', () => {
  const got = toNumbers(ok);
  assert.deepEqual(got, {amount: 60, tip: 15, people: 3}, `toNumbers lieferte ${JSON.stringify(got)}`);
});

test('ein Betrag, der nicht über 0 liegt, wirft: abc, 0, -5', () => {
  for (const amount of ['abc', '0', '-5']) {
    assert.throws(() => toNumbers({...ok, amount}), Error, `toNumbers mit amount "${amount}" sollte werfen`);
  }
});

test('ein Trinkgeld unter 0 oder keine Zahl wirft: -1, ten', () => {
  for (const tip of ['-1', 'ten']) {
    assert.throws(() => toNumbers({...ok, tip}), Error, `toNumbers mit tip "${tip}" sollte werfen`);
  }
});

test('people muss eine ganze Zahl ab 1 sein: 2.5 und 0 werfen', () => {
  for (const people of ['2.5', '0']) {
    assert.throws(() => toNumbers({...ok, people}), Error, `toNumbers mit people "${people}" sollte werfen`);
  }
});

test('die Meldung nennt den ungültigen Wert', () => {
  assert.throws(() => toNumbers({...ok, people: '2.5'}), {message: /2\.5/}, 'die Meldung für people "2.5" sollte 2.5 enthalten');
  assert.throws(() => toNumbers({...ok, amount: 'abc'}), {message: /abc/}, 'die Meldung für amount "abc" sollte abc enthalten');
});

{
  "type": "module"
}

import {parseArgs} from 'node:util';
import {format, splitBill, toNumbers} from './bill.js';

const USAGE = 'Usage: node main.js <amount> [--tip <percent>] [--people <count>]';

// Returns what to print on stdout and on stderr, and the exit code:
// 0 = done, 1 = a value it cannot use, 2 = wrong usage.
// It works for 60 --people 3, but every mistake ends up on stdout with code 0.
function run(args, env) {
  try {
    const {values, positionals} = parseArgs({
      args,
      options: {
        tip: {type: 'string', short: 't', default: '15'},
        people: {type: 'string', short: 'p', default: '1'}
      },
      allowPositionals: true
    });
    const bill = toNumbers({amount: positionals[0], tip: values.tip, people: values.people});
    return {out: format(splitBill(bill)), err: '', code: 0};
  } catch (error) {
    return {out: error.message + '\n' + USAGE + '\n', err: '', code: 0};
  }
}

// The only lines that touch the real process.
const {out, err, code} = run(process.argv.slice(2), process.env);
process.stdout.write(out);
process.stderr.write(err);
process.exitCode = code;

import {test} from 'node:test';
import assert from 'node:assert/strict';
import {runMain} from './learnrun.js';

test('60 --people 3 gibt das Trinkgeld, die Summe und jeden Anteil aus', async () => {
  const got = (await runMain({args: ['60', '--people', '3']})).trimEnd();
  assert.equal(got, 'tip: 9.00\ntotal: 69.00\neach: 23.00', `das Programm gab ${JSON.stringify(got)} aus`);
});

test('kurze Optionen funktionieren: -t 10 -p 3 100', async () => {
  const got = (await runMain({args: ['-t', '10', '-p', '3', '100']})).trimEnd();
  assert.equal(got, 'tip: 10.00\ntotal: 110.00\neach: 36.67', `das Programm gab ${JSON.stringify(got)} aus`);
});

test('TIP_PERCENT setzt das voreingestellte Trinkgeld, und --tip gewinnt trotzdem', async () => {
  process.env.TIP_PERCENT = '10';
  try {
    const byEnv = (await runMain({args: ['60']})).split('\n')[0];
    assert.equal(byEnv, 'tip: 6.00', `mit TIP_PERCENT=10 war die erste Zeile ${JSON.stringify(byEnv)}`);
    const byFlag = (await runMain({args: ['60', '--tip', '20']})).split('\n')[0];
    assert.equal(byFlag, 'tip: 12.00', `mit --tip 20 war die erste Zeile ${JSON.stringify(byFlag)}`);
  } finally {
    delete process.env.TIP_PERCENT;
  }
});

test('--help gibt die Usage-Zeile auf stdout aus', async () => {
  const got = await runMain({args: ['--help']});
  assert.match(got, /^Usage: node main\.js/, `--help gab ${JSON.stringify(got)} aus`);
});

test('kein Betrag: ein Exit-Code ungleich 0', async () => {
  await assert.rejects(runMain(), Error, 'node main.js ohne Betrag endete mit Exit-Code 0');
});

test('eine unbekannte Option: ein Exit-Code ungleich 0', async () => {
  await assert.rejects(runMain({args: ['60', '--colour']}), Error, 'node main.js 60 --colour endete mit Exit-Code 0');
});

test('der Betrag abc: ein Exit-Code ungleich 0', async () => {
  await assert.rejects(runMain({args: ['abc']}), Error, 'node main.js abc endete mit Exit-Code 0');
});

// Pure functions: no process, no console, so they run anywhere.

// Turns the text values from the command line into numbers, or throws.
export function toNumbers({amount, tip, people}) {
  const bill = {amount: Number(amount), tip: Number(tip), people: Number(people)};
  if (!(bill.amount > 0)) throw new Error('amount must be a number above 0, got "' + amount + '"');
  if (!(bill.tip >= 0)) throw new Error('tip must be a number from 0, got "' + tip + '"');
  if (!Number.isInteger(bill.people) || bill.people < 1) throw new Error('people must be a whole number from 1, got "' + people + '"');
  return bill;
}

// The tip, the total and each person's share, rounded to cents.
export function splitBill({amount, tip, people}) {
  const cents = (x) => Math.round(x * 100) / 100;
  const tipAmount = cents((amount * tip) / 100);
  const total = cents(amount + tipAmount);
  return {tip: tipAmount, total, each: cents(total / people)};
}

// The result as the lines the command prints.
export function format({tip, total, each}) {
  return 'tip: ' + tip.toFixed(2) + '\ntotal: ' + total.toFixed(2) + '\neach: ' + each.toFixed(2) + '\n';
}

{
  "type": "module"
}