@bitfinex/lib-js-util-math 0.7.1 → 1.0.0

package/test/bn.test.js

@@ -1,172 +1,174 @@
 'use strict'
 
 const { BigNumber } = require('bignumber.js')
-const chai = require('chai')
-  .use(require('dirty-chai'))
-const { expect } = chai
+const test = require('brittle')
 const { BN, nBN, validateBN } = require('../src/bn')
 
-module.exports = () => {
-  describe('# bn-tests', () => {
-    it('BN - should return BigNumber constructor', () => {
-      return expect(BN() === BigNumber).to.be.true
-    })
-
-    it('nBN - should fail on invalid string as number', () => {
-      return expect(nBN.bind(null, '12a')).to.throw()
-    })
-
-    it('nBN - should fail on invalid string as NaN', () => {
-      return expect(nBN.bind(null, 'NaN')).to.throw()
-    })
-
-    it('nBN - should fail on NaN type', () => {
-      return expect(nBN.bind(null, NaN)).to.throw()
-    })
-
-    it('nBN - should fail on null type', () => {
-      return expect(nBN.bind(null, null)).to.throw()
-    })
-
-    it('nBN - should fail on "null" value', () => {
-      return expect(nBN.bind(null, 'null')).to.throw()
-    })
-
-    it('nBN - should fail on bool value', () => {
-      return expect(nBN.bind(null, true)).to.throw()
-    })
-
-    it('nBN - should fail on infinite value', () => {
-      return expect(nBN.bind(null, Infinity)).to.throw('ERR_NUM_INFINITE')
-    })
-
-    it('nBN - should fail on -infinite value', () => {
-      return expect(nBN.bind(null, -Infinity)).to.throw('ERR_NUM_INFINITE')
-    })
-
-    it('nBN - should fail on infinity string value', () => {
-      return expect(nBN.bind(null, 'Infinity')).to.throw('ERR_NUM_INFINITE')
-    })
-
-    it('nBN - should work fail undefined input', () => {
-      return expect(nBN.bind(null)).to.throw()
-    })
-
-    it('nBN - should return BigNumber instance on valid input', () => {
-      return expect(nBN(33) instanceof BigNumber).to.be.true
-    })
-
-    it('nBN - should return BigNumber instance on valid BigNumber input', () => {
-      return expect(nBN(new BigNumber(0)) instanceof BigNumber).to.be.true
-    })
-
-    it('nBN - should return BigNumber instance on 0 input', () => {
-      return expect(nBN(0) instanceof BigNumber).to.be.true
-    })
-
-    it('nBN - should return BigNumber instance on string number input', () => {
-      return expect(nBN('3332') instanceof BigNumber).to.be.true
-    })
-
-    it('nBN - should return BigNumber instance on exponential number input', () => {
-      return expect(nBN(10e-2) instanceof BigNumber).to.be.true
-    })
-
-    it('nBN - should return BigNumber instance on exponential string number input', () => {
-      return expect(nBN('32.33e+2') instanceof BigNumber).to.be.true
-    })
-
-    it('nBN - should return BigNumber instance on decimal input', () => {
-      return expect(nBN(0.333) instanceof BigNumber).to.be.true
-    })
-
-    it('nBN - should return BigNumber instance on negative number input', () => {
-      return expect(nBN(-33) instanceof BigNumber).to.be.true
-    })
-
-    it('nBN - should return BigNumber instance on negative string number input', () => {
-      return expect(nBN('-33.323') instanceof BigNumber).to.be.true
-    })
-
-    it('validateBN - should fail on invalid string as NaN', () => {
-      return expect(
-        validateBN.bind(null, 'NaN')
-      ).to.throw()
-    })
-
-    it('validateBN - should fail on NaN type', () => {
-      return expect(
-        validateBN.bind(null, NaN)
-      ).to.throw()
-    })
-
-    it('validateBN - should fail on null type', () => {
-      return expect(
-        validateBN.bind(null, null)
-      ).to.throw()
-    })
-
-    it('validateBN - should fail on "null" value', () => {
-      return expect(
-        validateBN.bind(null, 'null')
-      ).to.throw()
-    })
-
-    it('validateBN - should fail on bool value', () => {
-      return expect(
-        validateBN.bind(null, true)
-      ).to.throw()
-    })
-
-    it('validateBN - should fail on infinite value', () => {
-      return expect(
-        validateBN.bind(null, Infinity)
-      ).to.throw('ERR_NUM_INFINITE')
-    })
-
-    it('validateBN - should fail on -infinite value', () => {
-      return expect(
-        validateBN.bind(null, -Infinity)
-      ).to.throw('ERR_NUM_INFINITE')
-    })
-
-    it('validateBN - should fail on infinity string value', () => {
-      return expect(
-        validateBN.bind(null, 'Infinity')
-      ).to.throw('ERR_NUM_INFINITE')
-    })
-
-    it('validateBN - should throw ERR_NUM_NAN on invalid number', () => {
-      return expect(
-        validateBN.bind(null, 'aa')
-      ).to.throw('ERR_NUM_NAN')
-    })
-
-    it('validateBN - should throw ERR_NUM_NOT_POS on negative number when restricted', () => {
-      return expect(
-        validateBN.bind(null, '-33', { allowNegative: false, allowZero: true, allowDecimals: true })
-      ).to.throw('ERR_NUM_NOT_POS')
-    })
-
-    it('validateBN - should throw ERR_NUM_ZERO on zero when restricted', () => {
-      return expect(
-        validateBN.bind(null, 0, { allowNegative: true, allowZero: false, allowDecimals: true })
-      ).to.throw('ERR_NUM_ZERO')
-    })
-
-    it('validateBN - should throw ERR_NUM_WITH_PRECISION on decimal number when restricted', () => {
-      expect(
-        validateBN.bind(null, '2e-7', { allowNegative: true, allowZero: true, allowDecimals: false })
-      ).to.throw('ERR_NUM_WITH_PRECISION')
-      return expect(
-        validateBN.bind(null, '0.33', { allowNegative: true, allowZero: true, allowDecimals: false })
-      ).to.throw('ERR_NUM_WITH_PRECISION')
-    })
-
-    it('validateBN - should work on any valid number with no restriction (default)', () => {
-      return expect(
-        validateBN.bind(null, '-0.33')
-      ).not.to.throw()
-    })
-  })
-}
+test('BN - should return BigNumber constructor', (t) => {
+  t.is(BN() === BigNumber, true)
+})
+
+test('nBN - should fail on invalid string as number', (t) => {
+  t.exception.all(nBN.bind(null, '12a'))
+})
+
+test('nBN - should fail on invalid string as NaN', (t) => {
+  t.exception.all(nBN.bind(null, 'NaN'))
+})
+
+test('nBN - should fail on NaN type', (t) => {
+  t.exception.all(nBN.bind(null, NaN))
+})
+
+test('nBN - should fail on null type', (t) => {
+  t.exception.all(nBN.bind(null, null))
+})
+
+test('nBN - should fail on "null" value', (t) => {
+  t.exception.all(nBN.bind(null, 'null'))
+})
+
+test('nBN - should fail on bool value', (t) => {
+  t.exception.all(nBN.bind(null, true))
+})
+
+test('nBN - should fail on infinite value', (t) => {
+  t.exception(nBN.bind(null, Infinity), /ERR_NUM_INFINITE/)
+})
+
+test('nBN - should fail on -infinite value', (t) => {
+  t.exception(nBN.bind(null, -Infinity), /ERR_NUM_INFINITE/)
+})
+
+test('nBN - should fail on infinity string value', (t) => {
+  t.exception(nBN.bind(null, 'Infinity'), /ERR_NUM_INFINITE/)
+})
+
+test('nBN - should work fail undefined input', (t) => {
+  t.exception.all(nBN.bind(null))
+})
+
+test('nBN - should return BigNumber instance on valid input', (t) => {
+  t.is(nBN(33) instanceof BigNumber, true)
+})
+
+test('nBN - should return BigNumber instance on valid BigNumber input', (t) => {
+  t.is(nBN(new BigNumber(0)) instanceof BigNumber, true)
+})
+
+test('nBN - should return BigNumber instance on 0 input', (t) => {
+  t.is(nBN(0) instanceof BigNumber, true)
+})
+
+test('nBN - should return BigNumber instance on string number input', (t) => {
+  t.is(nBN('3332') instanceof BigNumber, true)
+})
+
+test('nBN - should return BigNumber instance on exponential number input', (t) => {
+  t.is(nBN(10e-2) instanceof BigNumber, true)
+})
+
+test('nBN - should return BigNumber instance on exponential string number input', (t) => {
+  t.is(nBN('32.33e+2') instanceof BigNumber, true)
+})
+
+test('nBN - should return BigNumber instance on decimal input', (t) => {
+  t.is(nBN(0.333) instanceof BigNumber, true)
+})
+
+test('nBN - should return BigNumber instance on negative number input', (t) => {
+  t.is(nBN(-33) instanceof BigNumber, true)
+})
+
+test('nBN - should return BigNumber instance on negative string number input', (t) => {
+  t.is(nBN('-33.323') instanceof BigNumber, true)
+})
+
+test('validateBN - should fail on invalid string as NaN', (t) => {
+  t.exception.all(
+    validateBN.bind(null, 'NaN')
+  )
+})
+
+test('validateBN - should fail on NaN type', (t) => {
+  t.exception.all(
+    validateBN.bind(null, NaN)
+  )
+})
+
+test('validateBN - should fail on null type', (t) => {
+  t.exception.all(
+    validateBN.bind(null, null)
+  )
+})
+
+test('validateBN - should fail on "null" value', (t) => {
+  t.exception.all(
+    validateBN.bind(null, 'null')
+  )
+})
+
+test('validateBN - should fail on bool value', (t) => {
+  t.exception.all(
+    validateBN.bind(null, true)
+  )
+})
+
+test('validateBN - should fail on infinite value', (t) => {
+  t.exception(
+    validateBN.bind(null, Infinity),
+    /ERR_NUM_INFINITE/
+  )
+})
+
+test('validateBN - should fail on -infinite value', (t) => {
+  t.exception(
+    validateBN.bind(null, -Infinity),
+    /ERR_NUM_INFINITE/
+  )
+})
+
+test('validateBN - should fail on infinity string value', (t) => {
+  t.exception(
+    validateBN.bind(null, 'Infinity'),
+    /ERR_NUM_INFINITE/
+  )
+})
+
+test('validateBN - should throw ERR_NUM_NAN on invalid number', (t) => {
+  t.exception(
+    validateBN.bind(null, 'aa'),
+    /ERR_NUM_NAN/
+  )
+})
+
+test('validateBN - should throw ERR_NUM_NOT_POS on negative number when restricted', (t) => {
+  t.exception(
+    validateBN.bind(null, '-33', { allowNegative: false, allowZero: true, allowDecimals: true }),
+    /ERR_NUM_NOT_POS/
+  )
+})
+
+test('validateBN - should throw ERR_NUM_ZERO on zero when restricted', (t) => {
+  t.exception(
+    validateBN.bind(null, 0, { allowNegative: true, allowZero: false, allowDecimals: true }),
+    /ERR_NUM_ZERO/
+  )
+})
+
+test('validateBN - should throw ERR_NUM_WITH_PRECISION on decimal number when restricted', (t) => {
+  t.exception(
+    validateBN.bind(null, '2e-7', { allowNegative: true, allowZero: true, allowDecimals: false }),
+    /ERR_NUM_WITH_PRECISION/
+  )
+  t.exception(
+    validateBN.bind(null, '0.33', { allowNegative: true, allowZero: true, allowDecimals: false }),
+    /ERR_NUM_WITH_PRECISION/
+  )
+})
+
+test('validateBN - should work on any valid number with no restriction (default)', (t) => {
+  t.execution(
+    validateBN.bind(null, '-0.33')
+  )
+})

package/test/ema.test.js

@@ -1,34 +1,30 @@
 'use strict'
 
-const chai = require('chai')
-  .use(require('dirty-chai'))
-const { expect } = chai
+const test = require('brittle')
 const { EMA, multiplier } = require('../src/ema')
 
-module.exports = () => {
-  describe('# ema-tests', () => {
-    it('multiplier - it should fail with non numeric values', () => {
-      return expect(
-        multiplier.bind(null, 'a23')
-      ).to.throw()
-    })
+test('multiplier - it should fail with non numeric values', (t) => {
+  t.exception.all(
+    multiplier.bind(null, 'a23')
+  )
+})
 
-    it('multiplier - it should calc the expected value', () => {
-      return expect(
-        multiplier('10')
-      ).to.be.equal('0.18181818181818181818')
-    })
+test('multiplier - it should calc the expected value', (t) => {
+  t.is(
+    multiplier('10'),
+    '0.18181818181818181818'
+  )
+})
 
-    it('ema - it should fail with nan value', () => {
-      return expect(
-        EMA.bind(null, 'a7301.41', '7300.9807', 10)
-      ).to.throw()
-    })
+test('ema - it should fail with nan value', (t) => {
+  t.exception.all(
+    EMA.bind(null, 'a7301.41', '7300.9807', 10)
+  )
+})
 
-    it('ema - it should return the expected value', () => {
-      return expect(
-        EMA('7301.41', 7300.9807, '0.18181818181818181818')
-      ).to.be.equal('7301.058754545454545454544674')
-    })
-  })
-}
+test('ema - it should return the expected value', (t) => {
+  t.is(
+    EMA('7301.41', 7300.9807, '0.18181818181818181818'),
+    '7301.058754545454545454544674'
+  )
+})