@becollective/utils 1.2.0 → 1.3.0

package/bundle.js

@@ -84,9 +84,51 @@ var isUnderSixteen = function isUnderSixteen(dateOfBirth) {
   return isNaN(age) ? false : age < 16;
 };
 
+var _require = require('@becollective/constants'),
+    currencies = _require.currencies; // We should probably throw and error on bad input instead of falling back to a default.
+// We're making an assumption that whoever is calling this function can safely work
+// with AUD. But this assumption removes a lot of error handling elsewhere.
+
+
+var getCurrencyFromCurrencyCode = function getCurrencyFromCurrencyCode(currencyCode) {
+  if (typeof currencyCode !== 'string' || !currencies[currencyCode]) {
+    console.error(new Error("Invalid currencyCode: ".concat(currencyCode, ". Falling back to 'AUD'.")));
+    return currencies.AUD;
+  }
+
+  return currencies[currencyCode];
+};
+var makeMoneyString = function makeMoneyString(_ref) {
+  var inputAmount = _ref.amount,
+      currencyCode = _ref.currencyCode,
+      _ref$rounded = _ref.rounded,
+      rounded = _ref$rounded === void 0 ? false : _ref$rounded,
+      _ref$showCurrencyCode = _ref.showCurrencyCode,
+      showCurrencyCode = _ref$showCurrencyCode === void 0 ? false : _ref$showCurrencyCode;
+  var amount = Number(inputAmount);
+
+  if (isNaN(amount)) {
+    console.error(new Error("Invalid amount: ".concat(inputAmount, ". Falling back to 0.")));
+    amount = 0;
+  }
+
+  var currency = getCurrencyFromCurrencyCode(currencyCode);
+  var minorUnit = currency.minorUnit,
+      symbol = currency.symbol;
+  var decimalPlaces = rounded ? 0 : minorUnit;
+  var localeAmount = amount.toLocaleString(undefined, {
+    minimumFractionDigits: decimalPlaces,
+    maximumFractionDigits: decimalPlaces
+  });
+  var currencyCodeString = showCurrencyCode ? " ".concat(currency.code) : '';
+  return "".concat(symbol).concat(localeAmount).concat(currencyCodeString);
+};
+
 var util = {
   password: password,
   isUnderSixteen: isUnderSixteen,
-  getAge: getAge
+  getAge: getAge,
+  getCurrencyFromCurrencyCode: getCurrencyFromCurrencyCode,
+  makeMoneyString: makeMoneyString
 };
 module.exports = util;

package/index.js

@@ -1,10 +1,13 @@
-import { password } from './password';
-import { isUnderSixteen, getAge } from './date-time';
+import { password } from './src/password';
+import { isUnderSixteen, getAge } from './src/date-time';
+import { getCurrencyFromCurrencyCode, makeMoneyString } from './src/money';
 
 const util = {
   password,
   isUnderSixteen,
   getAge,
+  getCurrencyFromCurrencyCode,
+  makeMoneyString,
 };
 
 module.exports = util;

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@becollective/utils",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Common utilities",
   "main": "bundle.js",
   "scripts": {
-    "test": "NODE_ENV=localtest npm run build && ./node_modules/.bin/jest tests/*",
+    "test": "NODE_ENV=localtest npm run build && ./node_modules/.bin/jest",
     "build": "./node_modules/.bin/rollup -c",
-    "prepublish": "npm run build; npm test"
+    "prepare": "npm run build; npm test"
   },
   "author": "",
   "license": "ISC",
@@ -19,6 +19,15 @@
     "rollup-plugin-node-resolve": "^3.4.0"
   },
   "dependencies": {
+    "@becollective/constants": "^3.3.2",
     "moment": "^2.24.0"
+  },
+  "jest": {
+    "testMatch": [
+      "**/*.test.js"
+    ],
+    "setupFiles": [
+      "./testUtils/setup.js"
+    ]
   }
 }

package/{tests → src}/date-time.test.js

@@ -33,14 +33,14 @@ describe('isUnderSixteen', () => {
   test('Is not U16 if dob is 16 years ago', () => {
     const dob = moment(refPoint);
 
-    expect(isUnderSixteen(dob.subtract(1, 'second').utc().format())).toBe(false);
+    expect(isUnderSixteen(dob.subtract(1, 'minute').utc().format())).toBe(false);
     expect(isUnderSixteen(dob.subtract(100, 'year').utc().format())).toBe(false);
   });
 
   test('Is U16 if dob is less than 16 years ago', () => {
     const dob = moment(refPoint);
 
-    expect(isUnderSixteen(dob.add(1, 'second').utc().format())).toBe(true);
+    expect(isUnderSixteen(dob.add(1, 'minute').utc().format())).toBe(true);
     expect(isUnderSixteen(dob.add(100, 'year').utc().format())).toBe(true);
   });
 

package/src/money.js

@@ -0,0 +1,37 @@
+const { currencies } = require('@becollective/constants');
+
+// We should probably throw and error on bad input instead of falling back to a default.
+// We're making an assumption that whoever is calling this function can safely work
+// with AUD. But this assumption removes a lot of error handling elsewhere.
+export const getCurrencyFromCurrencyCode = currencyCode => {
+  if (typeof currencyCode !== 'string' || !currencies[currencyCode]) {
+    console.error(new Error(`Invalid currencyCode: ${currencyCode}. Falling back to 'AUD'.`));
+    return currencies.AUD;
+  }
+
+  return currencies[currencyCode];
+};
+
+export const makeMoneyString = ({
+  amount: inputAmount,
+  currencyCode,
+  rounded = false,
+  showCurrencyCode = false,
+}) => {
+  let amount = Number(inputAmount);
+  if (isNaN(amount)) {
+    console.error(new Error(`Invalid amount: ${inputAmount}. Falling back to 0.`));
+    amount = 0;
+  }
+
+  const currency = getCurrencyFromCurrencyCode(currencyCode);
+  const { minorUnit, symbol } = currency;
+
+  const decimalPlaces = rounded ? 0 : minorUnit;
+  const localeAmount = amount.toLocaleString(undefined, {
+    minimumFractionDigits: decimalPlaces,
+    maximumFractionDigits: decimalPlaces,
+  });
+  const currencyCodeString = showCurrencyCode ? ` ${currency.code}` : '';
+  return `${symbol}${localeAmount}${currencyCodeString}`;
+};

package/src/money.test.js

@@ -0,0 +1,99 @@
+const { currencies } = require('@becollective/constants');
+
+const { getCurrencyFromCurrencyCode, makeMoneyString } = require('../bundle.js');
+
+describe('getCurrencyFromCurrencyCode', () => {
+  test('Returns the correct currency', () => {
+    expect(getCurrencyFromCurrencyCode('AUD')).toMatchObject(currencies.AUD);
+    expect(getCurrencyFromCurrencyCode('NZD')).toMatchObject(currencies.NZD);
+    expect(getCurrencyFromCurrencyCode('GBP')).toMatchObject(currencies.GBP);
+  });
+
+  test('Returns AUD currency if currencyCode not found or invalid', () => {
+    const bogusCurrencyCodes = [
+      undefined,
+      1234,
+      'some junk that is not a currency code',
+      { foo: 'bar' },
+    ];
+    bogusCurrencyCodes.forEach(bogusCurrencyCode => {
+      expect(getCurrencyFromCurrencyCode(bogusCurrencyCode)).toMatchObject(currencies.AUD);
+    });
+  });
+});
+
+describe('makeMoneyString', () => {
+  test('Outputs a rounded money string', () => {
+    expect(
+      makeMoneyString({
+        amount: 123.05,
+        rounded: true,
+        currencyCode: 'AUD',
+      })
+    ).toEqual('$123');
+
+    expect(
+      makeMoneyString({
+        amount: 123.5,
+        rounded: true,
+        currencyCode: 'AUD',
+      })
+    ).toEqual('$124');
+
+    expect(
+      makeMoneyString({
+        amount: 123.95,
+        rounded: true,
+        currencyCode: 'AUD',
+      })
+    ).toEqual('$124');
+  });
+
+  test('Outputs a money string with currency code', () => {
+    expect(
+      makeMoneyString({
+        amount: 123.05,
+        currencyCode: 'NZD',
+        showCurrencyCode: true,
+      })
+    ).toEqual('$123.05 NZD');
+  });
+
+  test('Outputs a money string for AUD if bad input is provided', () => {
+    const bogusCurrencyCodes = [
+      undefined,
+      1234,
+      'some junk that is not a currency code',
+      { foo: 'bar' },
+    ];
+    bogusCurrencyCodes.forEach(bogusCurrencyCode => {
+      expect(
+        makeMoneyString({
+          amount: 123.05,
+          currencyCode: bogusCurrencyCode,
+          showCurrencyCode: true,
+        })
+      ).toEqual('$123.05 AUD');
+    });
+  });
+
+  test('Gracefully handles non-Number `amount` input', () => {
+    expect(
+      makeMoneyString({
+        amount: '100.25',
+        rounded: true,
+        currencyCode: 'GBP',
+      })
+    ).toEqual('£100');
+
+    const bogusAmountValues = [undefined, null, 'some junk that is not a number', { foo: 'bar' }];
+    bogusAmountValues.forEach(bogusAmountValue => {
+      expect(
+        makeMoneyString({
+          amount: bogusAmountValue,
+          currencyCode: 'GBP',
+        })
+      ).toEqual('£0.00');
+    });
+  });
+});

package/testUtils/setup.js

@@ -0,0 +1,21 @@
+process.env.NODE_ENV = 'localtest';
+
+let hasListened = false;
+if(!hasListened) {
+  hasListened = true;
+  process.on('unhandledRejection', (err) => {
+    console.debug(err.stack);
+  });
+}
+
+global.console = {
+  // These could be called in parts of the code for good reason but pollute the test output.
+  // So suppress the while testing.
+  // Ref: https://stackoverflow.com/questions/44467657/jest-better-way-to-disable-console-inside-unit-tests
+  log: jest.fn(),
+  error: jest.fn(),
+  warn: jest.fn(),
+  info: jest.fn(),
+  // Use console.debug if you need to debug while testing
+  debug: console.debug,
+};

package/tests/setup.js

@@ -1,9 +0,0 @@
-process.env.NODE_ENV = 'localtest';
-
-let hasListened = false;
-if(!hasListened) {
-  hasListened = true;
-  process.on('unhandledRejection', (err) => {
-    console.error(err.stack);
-  });
-}