Build: a tip calculator on the command line

// 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 with a 15% tip for 3 people: 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 returned ${JSON.stringify(got)}`);
});

test('each share is rounded to cents: 100 at 10% for 3 people is 36.67 each', () => {
  const got = splitBill({amount: 100, tip: 10, people: 3});
  assert.deepEqual(got, {tip: 10, total: 110, each: 36.67}, `splitBill returned ${JSON.stringify(got)}`);
});

test('the tip is rounded to cents: 19.99 at 15% gives a tip of 3', () => {
  const got = splitBill({amount: 19.99, tip: 15, people: 1});
  assert.deepEqual(got, {tip: 3, total: 22.99, each: 22.99}, `splitBill returned ${JSON.stringify(got)}`);
});

test('a 0% tip: the total is the amount', () => {
  const got = splitBill({amount: 80, tip: 0, people: 4});
  assert.deepEqual(got, {tip: 0, total: 80, each: 20}, `splitBill returned ${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" and "3" become the numbers 60, 15 and 3', () => {
  const got = toNumbers(ok);
  assert.deepEqual(got, {amount: 60, tip: 15, people: 3}, `toNumbers returned ${JSON.stringify(got)}`);
});

test('an amount that is not above 0 throws: abc, 0, -5', () => {
  for (const amount of ['abc', '0', '-5']) {
    assert.throws(() => toNumbers({...ok, amount}), Error, `toNumbers with amount "${amount}" should throw`);
  }
});

test('a tip below 0 or not a number throws: -1, ten', () => {
  for (const tip of ['-1', 'ten']) {
    assert.throws(() => toNumbers({...ok, tip}), Error, `toNumbers with tip "${tip}" should throw`);
  }
});

test('people must be a whole number from 1: 2.5 and 0 throw', () => {
  for (const people of ['2.5', '0']) {
    assert.throws(() => toNumbers({...ok, people}), Error, `toNumbers with people "${people}" should throw`);
  }
});

test('the message names the bad value', () => {
  assert.throws(() => toNumbers({...ok, people: '2.5'}), {message: /2\.5/}, 'the message for people "2.5" should contain 2.5');
  assert.throws(() => toNumbers({...ok, amount: 'abc'}), {message: /abc/}, 'the message for amount "abc" should contain abc');
});

{
  "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 prints the tip, the total and each share', async () => {
  const got = (await runMain({args: ['60', '--people', '3']})).trimEnd();
  assert.equal(got, 'tip: 9.00\ntotal: 69.00\neach: 23.00', `the program printed ${JSON.stringify(got)}`);
});

test('short options work: -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', `the program printed ${JSON.stringify(got)}`);
});

test('TIP_PERCENT sets the default tip, and --tip still wins', async () => {
  process.env.TIP_PERCENT = '10';
  try {
    const byEnv = (await runMain({args: ['60']})).split('\n')[0];
    assert.equal(byEnv, 'tip: 6.00', `with TIP_PERCENT=10, the first line was ${JSON.stringify(byEnv)}`);
    const byFlag = (await runMain({args: ['60', '--tip', '20']})).split('\n')[0];
    assert.equal(byFlag, 'tip: 12.00', `with --tip 20, the first line was ${JSON.stringify(byFlag)}`);
  } finally {
    delete process.env.TIP_PERCENT;
  }
});

test('--help prints the usage line on stdout', async () => {
  const got = await runMain({args: ['--help']});
  assert.match(got, /^Usage: node main\.js/, `--help printed ${JSON.stringify(got)}`);
});

test('no amount: an exit code other than 0', async () => {
  await assert.rejects(runMain(), Error, 'node main.js with no amount ended with exit code 0');
});

test('an unknown option: an exit code other than 0', async () => {
  await assert.rejects(runMain({args: ['60', '--colour']}), Error, 'node main.js 60 --colour ended with exit code 0');
});

test('the amount abc: an exit code other than 0', async () => {
  await assert.rejects(runMain({args: ['abc']}), Error, 'node main.js abc ended with 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"
}