From b9f488f6fd787666c3f164db834763d76cdbca09 Mon Sep 17 00:00:00 2001 From: rhyso Date: Mon, 7 Feb 2022 12:52:14 +0000 Subject: [PATCH] feat(GB): added tests for GB support --- __tests__/en-GB.test.ts | 235 ++++++++++++++++++++++++++++++++++++++++ dist/ToWords.js | 3 + dist/locales/en-GB.d.ts | 4 + dist/locales/en-GB.js | 62 +++++++++++ src/ToWords.ts | 2 +- 5 files changed, 305 insertions(+), 1 deletion(-) create mode 100644 __tests__/en-GB.test.ts create mode 100644 dist/locales/en-GB.d.ts create mode 100644 dist/locales/en-GB.js diff --git a/__tests__/en-GB.test.ts b/__tests__/en-GB.test.ts new file mode 100644 index 00000000..43759ded --- /dev/null +++ b/__tests__/en-GB.test.ts @@ -0,0 +1,235 @@ +import { cloneDeep } from 'lodash'; +import { ToWords } from '../src/ToWords'; +import enGb from '../src/locales/en-GB'; + +const localeCode = 'en-GB'; +const toWords = new ToWords({ + localeCode, +}); + +describe('Test Locale', () => { + test(`Locale Class: ${localeCode}`, () => { + expect(toWords.getLocaleClass()).toBe(enGb); + }); + + const wrongLocaleCode = localeCode + '-wrong'; + test(`Wrong Locale: ${wrongLocaleCode}`, () => { + const toWordsWrongLocale = new ToWords({ + localeCode: wrongLocaleCode, + }); + expect(() => toWordsWrongLocale.convert(1)).toThrow(/Unknown Locale/); + }); +}); + +const testIntegers = [ + [0, 'Zero'], + [137, 'One Hundred Thirty Seven'], + [700, 'Seven Hundred'], + [1100, 'One Thousand One Hundred'], + [4680, 'Four Thousand Six Hundred Eighty'], + [63892, 'Sixty Three Thousand Eight Hundred Ninety Two'], + [86100, 'Eighty Six Thousand One Hundred'], + [792581, 'Seven Hundred Ninety Two Thousand Five Hundred Eighty One'], + [2741034, 'Two Million Seven Hundred Forty One Thousand Thirty Four'], + [86429753, 'Eighty Six Million Four Hundred Twenty Nine Thousand Seven Hundred Fifty Three'], + [975310864, 'Nine Hundred Seventy Five Million Three Hundred Ten Thousand Eight Hundred Sixty Four'], + [9876543210, 'Nine Billion Eight Hundred Seventy Six Million Five Hundred Forty Three Thousand Two Hundred Ten'], + [ + 98765432101, + 'Ninety Eight Billion Seven Hundred Sixty Five Million Four Hundred Thirty Two Thousand One Hundred One', + ], + [ + 987654321012, + 'Nine Hundred Eighty Seven Billion Six Hundred Fifty Four Million Three Hundred Twenty One Thousand Twelve', + ], + [ + 9876543210123, + 'Nine Trillion Eight Hundred Seventy Six Billion Five Hundred Forty Three Million Two Hundred Ten Thousand One Hundred Twenty Three', + ], + [ + 98765432101234, + 'Ninety Eight Trillion Seven Hundred Sixty Five Billion Four Hundred Thirty Two Million One Hundred One Thousand Two Hundred Thirty Four', + ], +]; + +describe('Test Integers with options = {}', () => { + test.concurrent.each(testIntegers)('convert %d => %s', (input, expected) => { + expect(toWords.convert(input as number)).toBe(expected); + }); +}); + +describe('Test Negative Integers with options = {}', () => { + const testNegativeIntegers = cloneDeep(testIntegers); + testNegativeIntegers.map((row, i) => { + if (i === 0) { + return; + } + row[0] = -row[0]; + row[1] = `Minus ${row[1]}`; + }); + + test.concurrent.each(testNegativeIntegers)('convert %d => %s', (input, expected) => { + expect(toWords.convert(input as number)).toBe(expected); + }); +}); + +describe('Test Integers with options = { currency: true }', () => { + const testIntegersWithCurrency = cloneDeep(testIntegers); + testIntegersWithCurrency.map((row) => { + row[1] = `${row[1]} Pounds Only`; + }); + + test.concurrent.each(testIntegersWithCurrency)('convert %d => %s', (input, expected) => { + expect(toWords.convert(input as number, { currency: true })).toBe(expected); + }); +}); + +describe('Test Integers with options = { currency: true, doNotAddOnly: true }', () => { + const testIntegersWithCurrency = cloneDeep(testIntegers); + testIntegersWithCurrency.map((row) => { + row[1] = `${row[1]} Pounds`; + }); + + test.concurrent.each(testIntegersWithCurrency)('convert %d => %s', (input, expected) => { + expect(toWords.convert(input as number, { currency: true, doNotAddOnly: true })).toBe(expected); + }); +}); + +describe('Test Negative Integers with options = { currency: true }', () => { + const testNegativeIntegersWithCurrency = cloneDeep(testIntegers); + testNegativeIntegersWithCurrency.map((row, i) => { + if (i === 0) { + row[1] = `${row[1]} Pounds Only`; + return; + } + row[0] = -row[0]; + row[1] = `Minus ${row[1]} Pounds Only`; + }); + + test.concurrent.each(testNegativeIntegersWithCurrency)('convert %d => %s', (input, expected) => { + expect(toWords.convert(input as number, { currency: true })).toBe(expected); + }); +}); + +describe('Test Integers with options = { currency: true, ignoreZeroCurrency: true }', () => { + const testIntegersWithCurrencyAndIgnoreZeroCurrency = cloneDeep(testIntegers); + testIntegersWithCurrencyAndIgnoreZeroCurrency.map((row, i) => { + row[1] = i === 0 ? '' : `${row[1]} Pounds Only`; + }); + + test.concurrent.each(testIntegersWithCurrencyAndIgnoreZeroCurrency)('convert %d => %s', (input, expected) => { + expect( + toWords.convert(input as number, { + currency: true, + ignoreZeroCurrency: true, + }), + ).toBe(expected); + }); +}); + +const testFloats = [ + [0.0, 'Zero'], + [0.04, 'Zero Point Zero Four'], + [0.0468, 'Zero Point Zero Four Six Eight'], + [0.4, 'Zero Point Four'], + [0.63, 'Zero Point Sixty Three'], + [0.973, 'Zero Point Nine Hundred Seventy Three'], + [0.999, 'Zero Point Nine Hundred Ninety Nine'], + [37.06, 'Thirty Seven Point Zero Six'], + [37.068, 'Thirty Seven Point Zero Six Eight'], + [37.68, 'Thirty Seven Point Sixty Eight'], + [37.683, 'Thirty Seven Point Six Hundred Eighty Three'], +]; + +describe('Test Floats with options = {}', () => { + test.concurrent.each(testFloats)('convert %d => %s', (input, expected) => { + expect(toWords.convert(input as number)).toBe(expected); + }); +}); + +const testFloatsWithCurrency = [ + [0.0, `Zero Pounds Only`], + [0.04, `Zero Pounds And Four Pence Only`], + [0.0468, `Zero Pounds And Five Pence Only`], + [0.4, `Zero Pounds And Forty Pence Only`], + [0.63, `Zero Pounds And Sixty Three Pence Only`], + [0.973, `Zero Pounds And Ninety Seven Pence Only`], + [0.999, `One Pounds Only`], + [37.06, `Thirty Seven Pounds And Six Pence Only`], + [37.068, `Thirty Seven Pounds And Seven Pence Only`], + [37.68, `Thirty Seven Pounds And Sixty Eight Pence Only`], + [37.683, `Thirty Seven Pounds And Sixty Eight Pence Only`], +]; + +describe('Test Floats with options = { currency: true }', () => { + test.concurrent.each(testFloatsWithCurrency)('convert %d => %s', (input, expected) => { + expect(toWords.convert(input as number, { currency: true })).toBe(expected); + }); +}); + +describe('Test Floats with options = { currency: true, ignoreZeroCurrency: true }', () => { + const testFloatsWithCurrencyAndIgnoreZeroCurrency = cloneDeep(testFloatsWithCurrency); + testFloatsWithCurrencyAndIgnoreZeroCurrency[0][1] = ''; + testFloatsWithCurrencyAndIgnoreZeroCurrency.map((row, i) => { + if (i === 0) { + row[1] = ''; + return; + } + if (row[0] > 0 && row[0] < 1) { + row[1] = (row[1] as string).replace(`Zero Pounds And `, ''); + } + }); + + test.concurrent.each(testFloatsWithCurrencyAndIgnoreZeroCurrency)('convert %d => %s', (input, expected) => { + expect( + toWords.convert(input as number, { + currency: true, + ignoreZeroCurrency: true, + }), + ).toBe(expected); + }); +}); + +describe('Test Floats with options = { currency: true, ignoreDecimal: true }', () => { + const testFloatsWithCurrencyAndIgnoreDecimal = cloneDeep(testFloatsWithCurrency); + testFloatsWithCurrencyAndIgnoreDecimal.map((row) => { + if (row[0] === 0.999) { + row[1] = `Zero Pounds Only`; + } else { + row[1] = (row[1] as string).replace(new RegExp(` And [\\w ]+ Pence`), ''); + } + }); + + test.concurrent.each(testFloatsWithCurrencyAndIgnoreDecimal)('convert %d => %s', (input, expected) => { + expect( + toWords.convert(input as number, { + currency: true, + ignoreDecimal: true, + }), + ).toBe(expected); + }); +}); + +describe('Test Floats with options = { currency: true, ignoreZeroCurrency: true, ignoreDecimal: true }', () => { + const testFloatsWithCurrencyAndIgnoreZeroCurrencyAndIgnoreDecimals = cloneDeep(testFloatsWithCurrency); + testFloatsWithCurrencyAndIgnoreZeroCurrencyAndIgnoreDecimals[0][1] = ''; + testFloatsWithCurrencyAndIgnoreZeroCurrencyAndIgnoreDecimals.map((row) => { + if (row[0] > 0 && row[0] < 1) { + row[1] = ''; + } + row[1] = (row[1] as string).replace(new RegExp(` And [\\w ]+ Pence`), ''); + }); + + test.concurrent.each(testFloatsWithCurrencyAndIgnoreZeroCurrencyAndIgnoreDecimals)( + 'convert %d => %s', + (input, expected) => { + expect( + toWords.convert(input as number, { + currency: true, + ignoreZeroCurrency: true, + ignoreDecimal: true, + }), + ).toBe(expected); + }, + ); +}); diff --git a/dist/ToWords.js b/dist/ToWords.js index 7c8b6c86..c4ed6342 100644 --- a/dist/ToWords.js +++ b/dist/ToWords.js @@ -11,6 +11,7 @@ const en_MM_1 = __importDefault(require("./locales/en-MM")); const en_MU_1 = __importDefault(require("./locales/en-MU")); const en_NG_1 = __importDefault(require("./locales/en-NG")); const en_US_1 = __importDefault(require("./locales/en-US")); +const en_GB_1 = __importDefault(require("./locales/en-GB")); const fa_IR_1 = __importDefault(require("./locales/fa-IR")); const fr_FR_1 = __importDefault(require("./locales/fr-FR")); const gu_IN_1 = __importDefault(require("./locales/gu-IN")); @@ -50,6 +51,8 @@ class ToWords { return en_NG_1.default; case 'en-US': return en_US_1.default; + case 'en-GB': + return en_GB_1.default; case 'fa-IR': return fa_IR_1.default; case 'fr-FR': diff --git a/dist/locales/en-GB.d.ts b/dist/locales/en-GB.d.ts new file mode 100644 index 00000000..0727b4f2 --- /dev/null +++ b/dist/locales/en-GB.d.ts @@ -0,0 +1,4 @@ +import { LocaleConfig, LocaleInterface } from '../types'; +export default class Locale implements LocaleInterface { + config: LocaleConfig; +} diff --git a/dist/locales/en-GB.js b/dist/locales/en-GB.js new file mode 100644 index 00000000..ce5672b8 --- /dev/null +++ b/dist/locales/en-GB.js @@ -0,0 +1,62 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +class Locale { + constructor() { + this.config = { + currency: { + name: 'Pound', + plural: 'Pounds', + symbol: '£', + fractionalUnit: { + name: 'Pence', + plural: 'Pence', + symbol: '', + }, + }, + texts: { + and: 'And', + minus: 'Minus', + only: 'Only', + point: 'Point', + }, + numberWordsMapping: [ + { number: 1000000000000000, value: 'Quadrillion' }, + { number: 1000000000000, value: 'Trillion' }, + { number: 1000000000, value: 'Billion' }, + { number: 1000000, value: 'Million' }, + { number: 1000, value: 'Thousand' }, + { number: 100, value: 'Hundred' }, + { number: 90, value: 'Ninety' }, + { number: 80, value: 'Eighty' }, + { number: 70, value: 'Seventy' }, + { number: 60, value: 'Sixty' }, + { number: 50, value: 'Fifty' }, + { number: 40, value: 'Forty' }, + { number: 30, value: 'Thirty' }, + { number: 20, value: 'Twenty' }, + { number: 19, value: 'Nineteen' }, + { number: 18, value: 'Eighteen' }, + { number: 17, value: 'Seventeen' }, + { number: 16, value: 'Sixteen' }, + { number: 15, value: 'Fifteen' }, + { number: 14, value: 'Fourteen' }, + { number: 13, value: 'Thirteen' }, + { number: 12, value: 'Twelve' }, + { number: 11, value: 'Eleven' }, + { number: 10, value: 'Ten' }, + { number: 9, value: 'Nine' }, + { number: 8, value: 'Eight' }, + { number: 7, value: 'Seven' }, + { number: 6, value: 'Six' }, + { number: 5, value: 'Five' }, + { number: 4, value: 'Four' }, + { number: 3, value: 'Three' }, + { number: 2, value: 'Two' }, + { number: 1, value: 'One' }, + { number: 0, value: 'Zero' }, + ], + exactWordsMapping: [{ number: 100, value: 'One Hundred' }], + }; + } +} +exports.default = Locale; diff --git a/src/ToWords.ts b/src/ToWords.ts index 4fc9a980..81ac3a5c 100644 --- a/src/ToWords.ts +++ b/src/ToWords.ts @@ -53,7 +53,7 @@ export class ToWords { case 'en-US': return enUs; case 'en-GB': - return enGb; + return enGb; case 'fa-IR': return faIr; case 'fr-FR':