Merge pull request #168 from neaps/vitest

Switch tests to vitest

Author: bkeepers

.github/workflows/test.yml

@@ -21,4 +21,4 @@ jobs:
         uses: codecov/codecov-action@v5
         with:
           fail_ci_if_error: true
-          files: ./coverage/lcov.info
+          files: ./coverage/coverage-final.json

package.json

@@ -18,25 +18,23 @@
     "dist"
   ],
   "devDependencies": {
-    "@types/mocha": "^10.0.10",
     "@types/node": "^20.10.6",
     "@typescript-eslint/eslint-plugin": "^7.0.0",
     "@typescript-eslint/parser": "^7.0.0",
-    "c8": "^10.1.3",
+    "@vitest/coverage-v8": "^3.0.0",
     "eslint": "^8.18.0",
-    "mocha": "^10.0.0",
     "npm-run-all": "^4.1.5",
-    "tsx": "^4.7.0",
     "typescript": "^5.3.3",
     "vite": "^7.2.7",
-    "vite-plugin-dts": "^4.5.4"
+    "vite-plugin-dts": "^4.5.4",
+    "vitest": "^3.0.0"
   },
   "scripts": {
     "dev": "vite",
     "build": "vite build",
-    "test": "tsc && mocha --require tsx --extension ts --extension js --recursive",
+    "test": "vitest",
     "lint": "eslint ./src --ext .ts,.tsx,.js",
-    "coverage": "c8 --reporter=lcov mocha --require tsx --extension ts --extension js --recursive",
+    "coverage": "vitest run --coverage",
     "ci": "run-s lint build coverage",
     "prepare": "npm run build"
   }

test/astronomy/coefficients.ts

@@ -1,15 +1,15 @@
-import assert from 'assert'
+import { describe, it, expect } from 'vitest'
 import coefficients, {
   sexagesimalToDecimal
 } from '../../src/astronomy/coefficients.js'
 
 describe('astronomy coefficients', () => {
   it('converts a sexagesimal angle into decimal degrees', () => {
-    assert.ok(sexagesimalToDecimal(10, 10, 10, 10, 10) === 10.169447225)
-    assert.ok(sexagesimalToDecimal(10) === 10)
+    expect(sexagesimalToDecimal(10, 10, 10, 10, 10)).toBe(10.169447225)
+    expect(sexagesimalToDecimal(10)).toBe(10)
   })
 
   it('calculates terrestrial oliquity coefficients rewritten to T', () => {
-    assert.ok(coefficients.terrestrialObliquity[1] === -0.013002583333333335)
+    expect(coefficients.terrestrialObliquity[1]).toBe(-0.013002583333333335)
   })
 })

test/astronomy/index.ts

@@ -1,5 +1,4 @@
-import assert from 'assert'
-import closeTo from '../lib/close-to.js'
+import { describe, it, expect } from 'vitest'
 import astro, {
   polynomial,
   derivativePolynomial,
@@ -24,75 +23,75 @@ sampleTime.setMilliseconds(10)
 describe('astronomy', () => {
   it('complete astronomic calculation', () => {
     const result = astro(sampleTime)
-    closeTo(result.s.value, 258.23871057233191, 4)
-    closeTo(result.s.speed, 0.54901651929993922, 4)
+    expect(result.s.value).toBeCloseTo(258.23871057233191, 4)
+    expect(result.s.speed).toBeCloseTo(0.54901651929993922, 4)
 
-    closeTo(result.pp.value, 283.27697979858613, 4)
-    closeTo(result.pp.speed, 1.9612154426341654e-6, 4)
+    expect(result.pp.value).toBeCloseTo(283.27697979858613, 4)
+    expect(result.pp.speed).toBeCloseTo(1.9612154426341654e-6, 4)
 
-    closeTo(result.h.value, 192.82639897760328, 4)
-    closeTo(result.h.speed, 0.041068640143510367, 4)
+    expect(result.h.value).toBeCloseTo(192.82639897760328, 4)
+    expect(result.h.speed).toBeCloseTo(0.041068640143510367, 4)
 
-    closeTo(result.xi.value, 11.989946298635664, 4)
-    assert.ok(result.xi.speed === null)
+    expect(result.xi.value).toBeCloseTo(11.989946298635664, 4)
+    expect(result.xi.speed).toBeNull()
 
-    closeTo(result.I.value, 22.811296275568843, 4)
-    assert.ok(result.I.speed === null)
+    expect(result.I.value).toBeCloseTo(22.811296275568843, 4)
+    expect(result.I.speed).toBeNull()
 
-    closeTo(result.P.value, 155.24265065565865, 4)
-    assert.ok(result.P.speed === null)
+    expect(result.P.value).toBeCloseTo(155.24265065565865, 4)
+    expect(result.P.speed).toBeNull()
 
-    closeTo(result.nupp.value, 8.8162480626605451, 4)
-    assert.ok(result.nupp.speed === null)
+    expect(result.nupp.value).toBeCloseTo(8.8162480626605451, 4)
+    expect(result.nupp.speed).toBeNull()
 
-    closeTo(result.nu.value, 13.028571777192044, 4)
-    assert.ok(result.nu.speed === null)
+    expect(result.nu.value).toBeCloseTo(13.028571777192044, 4)
+    expect(result.nu.speed).toBeNull()
 
-    closeTo(result['T+h-s'].value, 268.50435506200392, 4)
-    closeTo(result['T+h-s'].speed, 14.492052120843571, 4)
+    expect(result['T+h-s'].value).toBeCloseTo(268.50435506200392, 4)
+    expect(result['T+h-s'].speed).toBeCloseTo(14.492052120843571, 4)
 
-    closeTo(result.omega.value, 23.436722306067253, 4)
-    closeTo(result.omega.speed, -1.4832917321024327e-8, 4)
+    expect(result.omega.value).toBeCloseTo(23.436722306067253, 4)
+    expect(result.omega.speed).toBeCloseTo(-1.4832917321024327e-8, 4)
   })
 
   it('evaluates a polynomial', () => {
-    assert.ok(polynomial([1, 2, 3], 3) === 34)
+    expect(polynomial([1, 2, 3], 3)).toBe(34)
   })
 
   it('evaluates derivative polynomials', () => {
-    assert.ok(derivativePolynomial([1, 2, 3], 3) === 20)
+    expect(derivativePolynomial([1, 2, 3], 3)).toBe(20)
   })
 
   it('evaluates Meeus formula 7.1 (JD) correctly', () => {
     sampleTime.setMonth(9)
-    closeTo(JD(sampleTime), 2458760.92755, 2)
+    expect(JD(sampleTime)).toBeCloseTo(2458760.92755, 2)
     // Months of less than 2 go back a year
     sampleTime.setMonth(0)
-    closeTo(JD(sampleTime), 2458487.92755, 2)
+    expect(JD(sampleTime)).toBeCloseTo(2458487.92755, 2)
   })
 
   it('evaluates Meeus formula 11.1 (T) correctly', () => {
     sampleTime.setMonth(9)
-    closeTo(T(sampleTime), 0.19756132, 2)
+    expect(T(sampleTime)).toBeCloseTo(0.19756132, 2)
   })
 
   it('evaluates value for _I correctly', () => {
-    closeTo(_I(4, 10, 5), 14.9918364991, 4)
+    expect(_I(4, 10, 5)).toBeCloseTo(14.9918364991, 4)
   })
 
   it('evaluates value for _xi correctly', () => {
-    closeTo(_xi(4, 3, 10), 0.911946348144, 4)
+    expect(_xi(4, 3, 10)).toBeCloseTo(0.911946348144, 4)
   })
 
   it('evaluates value for _nu correctly', () => {
-    closeTo(_nu(10, 4, 5), 4.45767377718, 4)
+    expect(_nu(10, 4, 5)).toBeCloseTo(4.45767377718, 4)
   })
 
   it('evaluates value for _nup correctly', () => {
-    closeTo(_nup(10, 4, 5), 2.13580480226, 4)
+    expect(_nup(10, 4, 5)).toBeCloseTo(2.13580480226, 4)
   })
 
   it('evaluates value for _nupp correctly', () => {
-    closeTo(_nupp(10, 4, 5), 1.1146589591, 4)
+    expect(_nupp(10, 4, 5)).toBeCloseTo(1.1146589591, 4)
   })
 })

test/constituents/compound-constituent.ts

@@ -1,5 +1,4 @@
-import assert from 'assert'
-import closeTo from '../lib/close-to.js'
+import { describe, it, expect } from 'vitest'
 import compoundConstituent from '../../src/constituents/compound-constituent.js'
 import Constituent from '../../src/constituents/constituent.js'
 import astro from '../../src/astronomy/index.js'
@@ -25,22 +24,22 @@ const compoundTest = compoundConstituent('test compound', [
 ])
 describe('compund constituent', () => {
   it('it calculates compound coefficients', () => {
-    assert.deepStrictEqual(compoundTest.coefficients, [1, 0, 0, 0, 0, 0, 0])
+    expect(compoundTest.coefficients).toEqual([1, 0, 0, 0, 0, 0, 0])
   })
 
   it('it calculates speed', () => {
-    closeTo(compoundTest.speed(testAstro), 14.4920521208, 4)
+    expect(compoundTest.speed(testAstro)).toBeCloseTo(14.4920521208, 4)
   })
 
   it('it calculates value', () => {
-    closeTo(compoundTest.value(testAstro), 268.504355062, 4)
+    expect(compoundTest.value(testAstro)).toBeCloseTo(268.504355062, 4)
   })
 
   it('it returns u correctly', () => {
-    assert.ok(compoundTest.u(testAstro) === 0)
+    expect(compoundTest.u(testAstro)).toBe(0)
   })
 
   it('it returns f correctly', () => {
-    assert.ok(compoundTest.f(testAstro) === 1)
+    expect(compoundTest.f(testAstro)).toBe(1)
   })
 })

test/constituents/constituent.ts

@@ -1,5 +1,4 @@
-import assert from 'assert'
-import closeTo from '../lib/close-to.js'
+import { describe, it, expect } from 'vitest'
 import constituent, {
   astronimicDoodsonNumber,
   astronomicSpeed,
@@ -23,45 +22,40 @@ const testConstituent = constituent('test', [1, 1, -1, 0, 0, 0, 1])
 
 describe('constituent', () => {
   it('it throws error if missing coefficients', () => {
-    let errorMessage = false
-    try {
-      const a = constituent('fail') // eslint-disable-line
-    } catch (error) {
-      errorMessage = error
-    }
-    assert.ok(
-      errorMessage.message === 'Coefficient must be defined for a constituent'
-    )
+    expect(() => {
+      // @ts-expect-error
+      constituent('fail')
+    }).toThrow('Coefficient must be defined for a constituent')
   })
 
   it('it fetches astronimic Doodson Number values', () => {
     const values = astronimicDoodsonNumber(testAstro)
-    assert.ok(values[0].value === testAstro['T+h-s'].value)
+    expect(values[0].value).toBe(testAstro['T+h-s'].value)
   })
 
   it('it fetches astronimic speed', () => {
     const values = astronomicSpeed(testAstro)
-    assert.ok(values[0] === testAstro['T+h-s'].speed)
+    expect(values[0]).toBe(testAstro['T+h-s'].speed)
   })
 
   it('it fetches astronimic values', () => {
     const values = astronomicValues(testAstro)
-    assert.ok(values[0] === testAstro['T+h-s'].value)
+    expect(values[0]).toBe(testAstro['T+h-s'].value)
   })
 
   it('it computes constituent value', () => {
-    closeTo(testConstituent.value(testAstro), 423.916666657, 4)
+    expect(testConstituent.value(testAstro)).toBeCloseTo(423.916666657, 4)
   })
 
   it('it computes constituent speed', () => {
-    assert.ok(testConstituent.speed(testAstro) === 15)
+    expect(testConstituent.speed(testAstro)).toBe(15)
   })
 
   it('it returns u correctly', () => {
-    assert.ok(testConstituent.u(testAstro) === 0)
+    expect(testConstituent.u(testAstro)).toBe(0)
   })
 
   it('it returns f correctly', () => {
-    assert.ok(testConstituent.f(testAstro) === 1)
+    expect(testConstituent.f(testAstro)).toBe(1)
   })
 })

test/constituents/index.ts

@@ -1,4 +1,4 @@
-import closeTo from '../lib/close-to.js'
+import { describe, it, expect } from 'vitest'
 import constituents from '../../src/constituents/index.js'
 import astro from '../../src/astronomy/index.js'
 
@@ -15,21 +15,21 @@ const testAstro = astro(sampleTime)
 
 describe('Base constituent definitions', () => {
   it('it prepared constituent SA', () => {
-    closeTo(constituents.SA.value(testAstro), 192.826398978, 4)
+    expect(constituents.SA.value(testAstro)).toBeCloseTo(192.826398978, 4)
   })
 
   it('it prepared constituent SSA', () => {
-    closeTo(constituents.SSA.value(testAstro), 385.652797955, 4)
+    expect(constituents.SSA.value(testAstro)).toBeCloseTo(385.652797955, 4)
   })
 
   it('it prepared constituent M2', () => {
-    closeTo(constituents.M2.value(testAstro), 537.008710124, 4)
-    closeTo(constituents.M2.u(testAstro), -2.07725095711, 4)
-    closeTo(constituents.M2.f(testAstro), 1.00853563237, 4)
+    expect(constituents.M2.value(testAstro)).toBeCloseTo(537.008710124, 4)
+    expect(constituents.M2.u(testAstro)).toBeCloseTo(-2.07725095711, 4)
+    expect(constituents.M2.f(testAstro)).toBeCloseTo(1.00853563237, 4)
   })
 
   it('has a correct lambda for M3', () => {
-    closeTo(constituents.M3.u(testAstro), -3.11587643567, 4)
-    closeTo(constituents.M3.f(testAstro), 1.01283073119, 4)
+    expect(constituents.M3.u(testAstro)).toBeCloseTo(-3.11587643567, 4)
+    expect(constituents.M3.f(testAstro)).toBeCloseTo(1.01283073119, 4)
   })
 })