Use jest (#605)

* migrate tests to jest

* remove chai & mocha

.eslintignore

@@ -1,4 +1,5 @@
 dist/
 coverage/
 webpack.config.js
-.eslintrc.js
+.eslintrc.js
+jest.config.js

jest.config.js

@@ -0,0 +1,5 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+}

package.json

@@ -27,8 +27,8 @@
     "format": "yarn prettier --write .",
     "format-check": "yarn prettier --check .",
     "run-ts": "TS_NODE_PROJECT=tsconfig.json node --loader ts-node/esm",
-    "test": "yarn run-ts ./node_modules/.bin/mocha **/*.test.ts",
-    "test-ci": "yarn run-ts ./node_modules/.bin/nyc yarn run-ts ./node_modules/.bin/mocha **/*.test.ts"
+    "test": "jest **/*.test.ts",
+    "test-ci": "yarn run-ts ./node_modules/.bin/nyc jest **/*.test.ts"
   },
   "nyc": {
     "extension": [
@@ -51,28 +51,27 @@
   },
   "devDependencies": {
     "@types/assert": "^1.4.3",
-    "@types/chai": "^4.2.7",
-    "@types/mocha": "^9.1.1",
+    "@types/jest": "^29.5.8",
     "@types/mockdate": "^3.0.0",
     "@types/node": "^17.0.41",
     "@typescript-eslint/eslint-plugin": "^5.27.1",
     "@typescript-eslint/parser": "^5.27.1",
-    "chai": "^4.2.0",
     "coverage": "^0.4.1",
     "eslint": "^8.17.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-import": "^2.26.0",
     "eslint-plugin-jsdoc": "^39.3.2",
     "eslint-plugin-prettier": "^4.0.0",
     "husky": "^8.0.1",
+    "jest": "^29.7.0",
     "lint-staged": "^13.0.1",
-    "mocha": "^10.0.0",
     "mockdate": "^3.0.5",
     "nyc": "^15.1.0",
     "prettier": "^2.6.2",
     "source-map-loader": "^3.0.1",
     "source-map-support": "^0.5.16",
     "terser-webpack-plugin": "^5.3.3",
+    "ts-jest": "^29.1.1",
     "ts-loader": "^9.3.0",
     "ts-node": "^10.8.1",
     "typescript": "^4.7.3",

test/cache.test.ts

@@ -1,5 +1,4 @@
 import { Cache } from '../src/cache'
-import { expect } from 'chai'
 import { IterArgs } from '../src/iterresult'
 
 const dates = [
@@ -21,7 +20,7 @@ describe('Cache', () => {
       inc: true,
     }
 
-    expect(cache._cacheGet('between', args)).to.be.false
+    expect(cache._cacheGet('between', args)).toBe(false)
   })
 
   it('returns an empty array for a cached but empty set', () => {
@@ -34,7 +33,7 @@ describe('Cache', () => {
 
     cache._cacheAdd('between', [], args)
 
-    expect(cache._cacheGet('between', args)).to.eql([])
+    expect(cache._cacheGet('between', args)).toEqual([])
   })
 
   it('returns cached entries if the "what" and the args both match', () => {
@@ -47,7 +46,7 @@ describe('Cache', () => {
 
     cache._cacheAdd('between', dates, args)
 
-    expect(cache._cacheGet('between', args)).to.eql(dates)
+    expect(cache._cacheGet('between', args)).toEqual(dates)
   })
 
   it('does not return cached entries if the "what" matches but the args do not', () => {
@@ -66,7 +65,7 @@ describe('Cache', () => {
         /** 1ms later than the args used for the insert */
         after: new Date('2021-01-01T00:00:00.001+00:00'),
       })
-    ).to.equal(false)
+    ).toBe(false)
   })
 
   it('does not return cached entries if args match but the "what" does not', () => {
@@ -79,7 +78,7 @@ describe('Cache', () => {
 
     cache._cacheAdd('between', dates, args)
 
-    expect(cache._cacheGet('after', args)).to.equal(false)
+    expect(cache._cacheGet('after', args)).toBe(false)
   })
 
   it('reuses dates cached for the "all" method when querying using another method', () => {
@@ -92,7 +91,7 @@ describe('Cache', () => {
 
     cache._cacheAdd('all', dates)
 
-    expect(cache._cacheGet('between', args)).to.eql([
+    expect(cache._cacheGet('between', args)).toEqual([
       new Date('2021-01-04T00:00:00.000+00:00'),
       new Date('2021-01-05T00:00:00.000+00:00'),
       new Date('2021-01-06T00:00:00.000+00:00'),

test/dateutil.test.ts

@@ -1,9 +1,8 @@
-import { expect } from 'chai'
 import { datetime, untilStringToDate } from '../src/dateutil'
 
 describe('untilStringToDate', () => {
   it('parses a date string', () => {
     const date = untilStringToDate('19970902T090000')
-    expect(date.getTime()).to.equal(datetime(1997, 9, 2, 9, 0, 0).getTime())
+    expect(date.getTime()).toBe(datetime(1997, 9, 2, 9, 0, 0).getTime())
   })
 })

test/datewithzone.test.ts

@@ -1,31 +1,30 @@
 import { DateWithZone } from '../src/datewithzone'
-import { expect } from 'chai'
 import { set as setMockDate, reset as resetMockDate } from 'mockdate'
 import { datetime, expectedDate } from './lib/utils'
 
 describe('toString', () => {
   it('returns the date when no tzid is present', () => {
     const dt = new DateWithZone(datetime(2010, 10, 5, 11, 0, 0))
-    expect(dt.toString()).to.equal(':20101005T110000Z')
+    expect(dt.toString()).toBe(':20101005T110000Z')
 
     const dt2 = new DateWithZone(datetime(2010, 10, 5, 11, 0, 0), 'UTC')
-    expect(dt2.toString()).to.equal(':20101005T110000Z')
+    expect(dt2.toString()).toBe(':20101005T110000Z')
   })
 
   it('returns the date with tzid when present', () => {
     const dt = new DateWithZone(datetime(2010, 10, 5, 11, 0, 0), 'Asia/Tokyo')
-    expect(dt.toString()).to.equal(';TZID=Asia/Tokyo:20101005T110000')
+    expect(dt.toString()).toBe(';TZID=Asia/Tokyo:20101005T110000')
   })
 })
 
 it('returns the time of the date', () => {
   const d = datetime(2010, 10, 5, 11, 0, 0)
   const dt = new DateWithZone(d)
-  expect(dt.getTime()).to.equal(d.getTime())
+  expect(dt.getTime()).toBe(d.getTime())
 })
 
 it('rejects invalid dates', () => {
-  expect(() => new DateWithZone(new Date(undefined))).to.throw(
+  expect(() => new DateWithZone(new Date(undefined))).toThrow(
     'Invalid date passed to DateWithZone'
   )
 })
@@ -34,7 +33,7 @@ describe('rezonedDate', () => {
   it('returns the original date when no zone is given', () => {
     const d = datetime(2010, 10, 5, 11, 0, 0)
     const dt = new DateWithZone(d)
-    expect(dt.rezonedDate()).to.deep.equal(d)
+    expect(dt.rezonedDate()).toEqual(d)
   })
 
   it('returns the date in the correct zone when given', () => {
@@ -44,7 +43,7 @@ describe('rezonedDate', () => {
 
     const d = new Date(Date.parse('2010-10-05T11:00:00'))
     const dt = new DateWithZone(d, targetZone)
-    expect(dt.rezonedDate()).to.deep.equal(
+    expect(dt.rezonedDate()).toEqual(
       expectedDate(
         new Date(Date.parse('2010-10-05T11:00:00')),
         currentLocalDate,

test/helpers.test.ts

@@ -10,138 +10,133 @@ import {
   isPresent,
   isArray,
 } from '../src/helpers'
-import { expect } from 'chai'
 import { isNumber } from 'util'
 
 describe('isPresent', () => {
   it('is false if object is null', () => {
-    expect(isPresent(null)).to.be.false
+    expect(isPresent(null)).toBe(false)
   })
 
   it('is false if object is undefined', () => {
-    expect(isPresent(undefined)).to.be.false
+    expect(isPresent(undefined)).toBe(false)
   })
 
   it('is true if object is non-null and not undefined', () => {
-    expect(isPresent(0)).to.be.true
-    expect(isPresent('')).to.be.true
-    expect(isPresent('foo')).to.be.true
-    expect(isPresent(123)).to.be.true
-    expect(isPresent([])).to.be.true
+    expect(isPresent(0)).toBe(true)
+    expect(isPresent('')).toBe(true)
+    expect(isPresent('foo')).toBe(true)
+    expect(isPresent(123)).toBe(true)
+    expect(isPresent([])).toBe(true)
   })
 })
 
 describe('isArray', () => {
   it('is true if it is an array', () => {
-    expect(isArray([])).to.be.true
-    expect(isArray([1])).to.be.true
-    expect(isArray(['foo'])).to.be.true
+    expect(isArray([])).toBe(true)
+    expect(isArray([1])).toBe(true)
+    expect(isArray(['foo'])).toBe(true)
   })
 
   it('is false if it is empty', () => {
-    expect(isArray('foo')).to.be.false
-    expect(isArray(null)).to.be.false
-    expect(isArray(0)).to.be.false
-    expect(isArray(undefined)).to.be.false
+    expect(isArray('foo')).toBe(false)
+    expect(isArray(null)).toBe(false)
+    expect(isArray(0)).toBe(false)
+    expect(isArray(undefined)).toBe(false)
   })
 })
 
 describe('isNumber', () => {
   it('is true if it is a number', () => {
-    expect(isNumber(0)).to.be.true
+    expect(isNumber(0)).toBe(true)
   })
 
   it('is false if it is not a number', () => {
-    expect(isNumber('1')).to.be.false
-    expect(isNumber(null)).to.be.false
+    expect(isNumber('1')).toBe(false)
+    expect(isNumber(null)).toBe(false)
   })
 })
 
 describe('empty', () => {
   it('is empty if object is null', () => {
-    expect(empty(null)).to.be.true
+    expect(empty(null)).toBe(true)
   })
 
   it('is empty if object is undefined', () => {
-    expect(empty(undefined)).to.be.true
+    expect(empty(undefined)).toBe(true)
   })
 
   it('is empty if object is an empty array', () => {
-    expect(empty([])).to.be.true
+    expect(empty([])).toBe(true)
   })
 
   it('is not empty if object is a non-empty array', () => {
-    expect(empty(['foo'])).to.be.false
-    expect(empty([0])).to.be.false
+    expect(empty(['foo'])).toBe(false)
+    expect(empty([0])).toBe(false)
   })
 })
 
 describe('includes', () => {
   it('is true if the object is found', () => {
-    expect(includes(['foo'], 'foo')).to.be.true
-    expect(includes([0], 0)).to.be.true
+    expect(includes(['foo'], 'foo')).toBe(true)
+    expect(includes([0], 0)).toBe(true)
   })
 
   it('is false if the object is not found', () => {
-    expect(includes(['foo'], 'bar')).to.be.false
-    expect(includes([0], 1)).to.be.false
+    expect(includes(['foo'], 'bar')).toBe(false)
+    expect(includes([0], 1)).toBe(false)
   })
 })
 
 describe('pymod', () => {
   it('returns the wrapped result', () => {
-    expect(pymod(1, 8)).to.equal(1)
-    expect(pymod(-1, -8)).to.equal(-1)
-    expect(pymod(-1, 8)).to.equal(7)
+    expect(pymod(1, 8)).toBe(1)
+    expect(pymod(-1, -8)).toBe(-1)
+    expect(pymod(-1, 8)).toBe(7)
   })
 })
 
 describe('divmod', () => {
   it('returns the divided result', () => {
-    expect(divmod(1, 8)).to.deep.equal({ div: 0, mod: 1 })
-    expect(divmod(-1, -8)).to.deep.equal({ div: 0, mod: -1 })
-    expect(divmod(-1, 8)).to.deep.equal({ div: -1, mod: 7 })
+    expect(divmod(1, 8)).toEqual({ div: 0, mod: 1 })
+    expect(divmod(-1, -8)).toEqual({ div: 0, mod: -1 })
+    expect(divmod(-1, 8)).toEqual({ div: -1, mod: 7 })
   })
 })
 
 describe('split', () => {
   it('splits on the separator', () => {
-    expect(split('one-two-three', '-', 0)).to.deep.equal([
-      'one',
-      'two',
-      'three',
-    ])
+    expect(split('one-two-three', '-', 0)).toEqual(['one', 'two', 'three'])
   })
 
   it('only splits the specified number when nonzero', () => {
-    expect(split('one-two-three', '-', 1)).to.deep.equal(['one', 'two-three'])
+    expect(split('one-two-three', '-', 1)).toEqual(['one', 'two-three'])
   })
 })
 
 describe('clone', () => {
   it('copies an array', () => {
     const a = ['a', 'b', 'c']
-    expect(clone(a)).not.to.equal(a)
-    expect(clone(a)).to.deep.equal(a)
+    expect(clone(a)).not.toBe(a)
+    expect(clone(a)).toEqual(a)
   })
 })
 
 describe('range', () => {
   it('generates a range', () => {
-    expect(range(3, 7)).to.deep.equal([3, 4, 5, 6])
+    expect(range(3, 7)).toEqual([3, 4, 5, 6])
   })
 
   it('generates to the first argument if no second argument is given', () => {
-    expect(range(7)).to.deep.equal([0, 1, 2, 3, 4, 5, 6])
+    expect(range(7)).toEqual([0, 1, 2, 3, 4, 5, 6])
   })
 })
 
 describe('repeat', () => {
   it('repeats a single item', () => {
-    expect(repeat('foo', 3)).to.deep.equal(['foo', 'foo', 'foo'])
+    expect(repeat('foo', 3)).toEqual(['foo', 'foo', 'foo'])
   })
 
   it('repeats an array', () => {
-    expect(repeat(['foo'], 3)).to.deep.equal([['foo'], ['foo'], ['foo']])
+    expect(repeat(['foo'], 3)).toEqual([['foo'], ['foo'], ['foo']])
   })
 })