Commit

1 files changed, 220 insertions, 0 deletions

diff --git a/src/node_modules/chance/test/test.finance.js b/src/node_modules/chance/test/test.finance.js
new file mode 100644
index 0000000..0b6e20a
--- /dev/null
+++ b/src/node_modules/chance/test/test.finance.js
@@ -0,0 +1,220 @@
+import test from 'ava'
+import Chance from '../chance.js'
+import _ from 'lodash'
+
+const chance = new Chance()
+
+// chance.cc()
+test('cc() passes the luhn algorithm', t => {
+    _.times(1000, () => {
+        let number = chance.cc()
+        t.true(chance.luhn_check(number))
+    })
+})
+
+test('cc() can take a type arg and obey it', t => {
+    _.times(1000, () => {
+        let type = chance.cc_type({ raw: true })
+        let number = chance.cc({ type: type.name })
+        t.is(number.length, type.length)
+    })
+})
+
+test('cc() can take a short_name type arg and obey it', t => {
+    _.times(1000, () => {
+        let type = chance.cc_type({ raw: true })
+        let number = chance.cc({ type: type.short_name })
+        t.is(number.length, type.length)
+    })
+})
+
+// chance.cc_type()
+test('cc_type() returns a random credit card type', t => {
+    _.times(1000, () => {
+        t.true(_.isString(chance.cc_type()))
+    })
+})
+
+test('cc_type() can take a raw arg and obey it', t => {
+    _.times(1000, () => {
+        let type = chance.cc_type({ raw: true })
+        t.truthy(type.name)
+        t.truthy(type.short_name)
+        t.truthy(type.prefix)
+        t.truthy(type.length)
+    })
+})
+
+test('cc_type() can take a name arg and obey it', t => {
+    _.times(1000, () => {
+        let type = chance.cc_type({ name: 'Visa', raw: true })
+        t.is(type.name, 'Visa')
+    })
+})
+
+test('cc_type() with bogus type throws', t => {
+    const fn = () => chance.cc_type({ name: 'potato' })
+    t.throws(fn, 'Chance: Credit card type \'potato\' is not supported')
+})
+
+// chance.cc_types()
+test('cc_types() returns an array of credit card types', t => {
+    t.true(_.isArray(chance.cc_types()))
+})
+
+// chance.currency()
+test('currency() returns a currency', t => {
+    _.times(1000, () => {
+        let currency = chance.currency()
+        t.true(_.isObject(currency))
+        t.truthy(currency.code)
+        t.is(currency.code.length, 3)
+        t.truthy(currency.name)
+    })
+})
+
+// chance.currency_pair()
+test('currency_pair() returns a currency pair', t => {
+    _.times(1000, () => {
+        let currency_pair = chance.currency_pair()
+        t.true(_.isArray(currency_pair))
+        t.is(currency_pair.length, 2)
+        t.not(currency_pair[0].code, currency_pair[1].code)
+    })
+})
+
+test('currency_pair() can return string version', t => {
+    _.times(1000, () => {
+        let currency_pair = chance.currency_pair(true)
+        t.true(_.isString(currency_pair))
+        t.is(currency_pair.length, 7)
+        t.true(/^[A-Z][A-Z][A-Z]+\/[A-Z][A-Z][A-Z]$/.test(currency_pair))
+    })
+})
+
+// chance.dollar()
+test('dollar() returns a proper dollar amount', t => {
+    let dollar = chance.dollar()
+    t.true(/\$[0-9]+\.[0-9]+/.test(dollar))
+    let dollarFloat = parseFloat(dollar.substring(1, dollar.length))
+    t.true(dollarFloat < 10001)
+})
+
+test('dollar() obeys min and max, if provided', t => {
+    _.times(1000, () => {
+        let dollar = chance.dollar({ max: 20 })
+        let dollarFloat = parseFloat(dollar.substring(1, dollar.length))
+        t.true(dollarFloat <= 20)
+    })
+
+    _.times(1000, () => {
+        let dollar = chance.dollar({ min: 20 })
+        let dollarFloat = parseFloat(dollar.substring(1, dollar.length))
+        t.true(dollarFloat >= 20)
+    })
+})
+
+test('dollar() can take negative min and max', t => {
+    _.times(1000, () => {
+        let dollar = chance.dollar({ min: -200, max: -1 })
+        t.is(dollar.charAt(0), '-')
+        let dollarFloat = parseFloat(dollar.substring(2, dollar.length))
+        // This is necessary because we strip the - when parsing
+        dollarFloat *= -1
+        t.true(dollarFloat <= -1)
+        t.true(dollarFloat >= -200)
+    })
+})
+
+// chance.euro()
+test('euro() returns a proper euro amount', t => {
+    let euro = chance.euro()
+    t.true(/[0-9]+,?\.?[0-9]+?€/.test(euro))
+    let euroFloat = parseFloat(euro.substring(euro.length, -1))
+    t.true(euroFloat < 10001)
+})
+
+// chance.exp()
+test('exp() looks correct', t => {
+    _.times(1000, () => {
+        let exp = chance.exp()
+        t.true(_.isString(exp))
+        t.is(exp.length, 7)
+        t.true(/([0-9]{2})\/([0-9]{4})/.test(exp))
+    })
+})
+
+test('exp() will respect object argument', t => {
+    _.times(1000, () => {
+        let exp = chance.exp({ raw: true })
+        t.true(_.isObject(exp))
+        t.truthy(exp.month)
+        t.true(_.isString(exp.month))
+        t.truthy(exp.year)
+        t.true(_.isString(exp.year))
+    })
+})
+
+test('exp() returs a valid credit card expiration (in a future date)', t => {
+    _.times(1000, () => {
+        let exp = chance.exp({ raw: true })
+        let now = new Date()
+        let nowMonth = now.getMonth() + 1
+        let nowYear = now.getFullYear()
+        let expMonth = parseInt(exp.month, 10)
+        let expYear = parseInt(exp.year, 10)
+
+        t.true(expYear >= nowYear)
+        if (expYear === nowYear) {
+            t.true(expMonth >= nowMonth)
+        }
+    })
+})
+
+// chance.exp_month()
+test('exp_month() returns a numeric month with leading 0', t => {
+    _.times(1000, () => {
+        let month = chance.exp_month()
+        t.true(_.isString(month))
+        t.is(month.length, 2)
+    })
+})
+
+// chance.exp_year()
+test('exp_year() returns an expiration year', t => {
+    _.times(1000, () => {
+        let year = chance.exp_year()
+        t.true(_.isString(year))
+        let parsedYear = parseInt(year, 10)
+        let curYear = new Date().getFullYear()
+        t.true(parsedYear >= curYear)
+        t.true(parsedYear <= curYear + 10)
+    })
+})
+
+test('exp_month() will return a future month if requested', t => {
+    _.times(1000, () => {
+        let nowMonth = new Date().getMonth() + 1
+        let expMonth = parseInt(chance.exp_month({ future: true }), 10)
+        if (nowMonth !== 12) {
+            t.true(expMonth > nowMonth)
+        } else {
+            t.true(expMonth >= 1)
+            t.true(expMonth <= 12)
+        }
+    })
+})
+
+// chance.luhn_check()
+test('luhn_check() properly checks if number passes the Luhn algorithm', t => {
+    t.true(chance.luhn_check(49927398716))
+    t.true(chance.luhn_check(1234567812345670))
+    t.false(chance.luhn_check(49927398717))
+    t.false(chance.luhn_check(1234567812345678))
+})
+
+test('iban() returns an iban', t => {
+    let iban = chance.iban()
+    t.true(_.isString(iban))
+    t.true(/^[A-Z]{2}[0-9]{2}[A-Z0-9]{4}[0-9]{1,26}$/.test(iban))
+})