use old tape test format again

Author: spencermountain

package-lock.json

@@ -25,9 +25,9 @@
     "pack": "node ./zonefile/pack.js",
     "version": "node ./scripts/version.js",
     "watch": "node --watch ./scratch.js",
-    "test": "node --test --test-reporter=./scripts/testReporter.js ./test/*.test.js | tap-dancer  --color always",
-    "testb": "echo '== production build test 🚀 ==' && TESTENV=prod node --test --test-reporter=./scripts/testReporter.js ./test/*.test.js | tap-dancer  --color always",
-    "test:types": "node --import tsx --test --test-reporter=./scripts/testReporter.js ./test/types/index.ts | tap-dancer  --color always",
+    "test": "tape ./test/**/*.test.js | tap-dancer  --color always",
+    "testb": "TESTENV=prod tape ./test/**/*.test.js | tap-dancer  --color always",
+    "test:types": "tsx ./test/types/index.ts | tap-dancer  --color always",
     "coverage": "nyc -r lcov -n 'src/**/*' -n 'plugins/**/*' npm run coverage:tests",
     "coverage:tests": "npm run test",
     "codecov": "npm run coverage && codecov -t 411de6c7-82d2-41e9-a1cc-9096cdab6c72",
@@ -57,10 +57,12 @@
     "@rollup/plugin-node-resolve": "^16.0.3",
     "@rollup/plugin-terser": "^1.0.0",
     "@types/node": "25.9.1",
+    "@types/tape": "5.8.1",
     "eslint-plugin-regexp": "3.1.0",
     "rollup": "4.60.4",
     "shelljs": "0.10.0",
     "tap-dancer": "0.3.4",
+    "tape": "5.9.0",
     "timekeeper": "2.3.1",
     "tslib": "2.8.1",
     "tsx": "4.22.3",

package.json

@@ -1,71 +1,71 @@
-import { test } from 'node:test'
-import assert from './lib/assert.js'
+import test from 'tape'
 import spacetime from './lib/index.js'
 
-test('add', () => {
+test('add', (t) => {
   let s = spacetime('January 1, 2017 1:20:05', 'Canada/Eastern')
   //initial state
-  assert.equal(s.date(), 1, '.date()')
-  assert.equal(s.monthName(), 'january', '.month()')
-  assert.equal(s.year(), 2017, '.year()')
-  assert.equal(s.hour(), 1, '.hour()')
-  assert.equal(s.minute(), 20, '.minute()')
-  assert.equal(s.dayName(), 'sunday', '.day()')
+  t.equal(s.date(), 1, '.date()')
+  t.equal(s.monthName(), 'january', '.month()')
+  t.equal(s.year(), 2017, '.year()')
+  t.equal(s.hour(), 1, '.hour()')
+  t.equal(s.minute(), 20, '.minute()')
+  t.equal(s.dayName(), 'sunday', '.day()')
 
   s = s.add(1, 'hour')
-  assert.equal(s.hour(), 2, 'movehour-.hour()')
-  assert.equal(s.minute(), 20, 'movehour-.minute()')
-  assert.equal(s.date(), 1, 'movehour-.date()')
-  assert.equal(s.month(), 0, 'movehour-.month()')
-  assert.equal(s.year(), 2017, 'movehour-.year()')
+  t.equal(s.hour(), 2, 'movehour-.hour()')
+  t.equal(s.minute(), 20, 'movehour-.minute()')
+  t.equal(s.date(), 1, 'movehour-.date()')
+  t.equal(s.month(), 0, 'movehour-.month()')
+  t.equal(s.year(), 2017, 'movehour-.year()')
 
   s = s.add(1, 'month')
-  assert.equal(s.date(), 1, 'movemonth.date()')
-  assert.equal(s.monthName(), 'february', 'movemonth.month()')
-  assert.equal(s.year(), 2017, 'movemonth.year()')
+  t.equal(s.date(), 1, 'movemonth.date()')
+  t.equal(s.monthName(), 'february', 'movemonth.month()')
+  t.equal(s.year(), 2017, 'movemonth.year()')
 
   s = s.add(2, 'days')
-  assert.equal(s.date(), 3, 'moveday-.date()')
-  assert.equal(s.monthName(), 'february', 'moveday-.month()')
-  assert.equal(s.year(), 2017, 'moveday-.year()')
-  assert.equal(s.dayName(), 'friday', 'moveday-.day()')
+  t.equal(s.date(), 3, 'moveday-.date()')
+  t.equal(s.monthName(), 'february', 'moveday-.month()')
+  t.equal(s.year(), 2017, 'moveday-.year()')
+  t.equal(s.dayName(), 'friday', 'moveday-.day()')
 
   s = s.add(1, 'week')
-  assert.equal(s.date(), 10, 'moveweek-.date()')
-  assert.equal(s.monthName(), 'february', 'moveweek-.month()')
-  assert.equal(s.year(), 2017, 'moveweek-.year()')
-  assert.equal(s.dayName(), 'friday', 'moveweek-.day()')
+  t.equal(s.date(), 10, 'moveweek-.date()')
+  t.equal(s.monthName(), 'february', 'moveweek-.month()')
+  t.equal(s.year(), 2017, 'moveweek-.year()')
+  t.equal(s.dayName(), 'friday', 'moveweek-.day()')
 
   s = s.add(1, 'year')
-  assert.equal(s.date(), 10, 'moveyear.date()')
-  assert.equal(s.monthName(), 'february', 'moveyear.month()')
-  assert.equal(s.year(), 2018, 'moveyear.year()')
+  t.equal(s.date(), 10, 'moveyear.date()')
+  t.equal(s.monthName(), 'february', 'moveyear.month()')
+  t.equal(s.year(), 2018, 'moveyear.year()')
 
   s = spacetime('January 1, 2017 1:20:05', 'Canada/Eastern')
   // s.add(1, 'quarter');
-  // assert.equal(s.date(), 1, 'movequarter.date()');
-  // assert.equal(s.monthName(), 'april', 'movequarter.date()');
+  // t.equal(s.date(), 1, 'movequarter.date()');
+  // t.equal(s.monthName(), 'april', 'movequarter.date()');
   s = s.add(2, 'years')
-  assert.equal(s.date(), 1, 'moveyear-.date()')
-  // assert.equal(s.monthName(), 'april', 'moveyear.month()');
-  assert.equal(s.year(), 2019, 'moveyear.year()')
+  t.equal(s.date(), 1, 'moveyear-.date()')
+  // t.equal(s.monthName(), 'april', 'moveyear.month()');
+  t.equal(s.year(), 2019, 'moveyear.year()')
 
   s = s.add(1, 'decade')
-  assert.equal(s.year(), 2029, 'move-decade.year()')
+  t.equal(s.year(), 2029, 'move-decade.year()')
 
   s = s.add(1, 'quarterHour')
-  assert.equal(s.minute(), 35, 'movequarterHour')
+  t.equal(s.minute(), 35, 'movequarterHour')
 
   s = s.add(1, 'quarterHour')
-  assert.equal(s.minute(), 50, 'movequarterHour#2')
+  t.equal(s.minute(), 50, 'movequarterHour#2')
 
   s = s.time('3:31pm')
   s = s.add(4, 'quarter-hour')
-  assert.equal(s.time(), '4:31pm', 'add 2 quarter-hours')
+  t.equal(s.time(), '4:31pm', 'add 2 quarter-hours')
 
+  t.end()
 })
 
-test('adding 0 changes nothing', () => {
+test('adding 0 changes nothing', (t) => {
   let s = spacetime.now()
   const a = s.clone()
   s = s.add(0, 'month')
@@ -76,79 +76,86 @@ test('adding 0 changes nothing', () => {
   s = s.add(0, 'minute')
   s = s.minus(0, 'minute')
   s = s.minus(0, 'days')
-  assert.equal(s.epoch, a.epoch, 'time-didnt change')
+  t.equal(s.epoch, a.epoch, 'time-didnt change')
 
   s = spacetime('dec 25 2018')
   const before = s.format('nice-year')
   s = s.add(0, 'years')
-  assert.equal(s.format('nice-year'), before, 'year didnt change')
+  t.equal(s.format('nice-year'), before, 'year didnt change')
+  t.end()
 })
 
-test('hour-tricky', () => {
+test('hour-tricky', (t) => {
   let s = spacetime('January 1, 2017 13:20:00', 'Canada/Pacific')
-  assert.equal(s.hour(), 13, 'init.hour()')
-  assert.equal(s.minute(), 20, 'init.minute()')
+  t.equal(s.hour(), 13, 'init.hour()')
+  t.equal(s.minute(), 20, 'init.minute()')
 
   s = s.add(1, 'hour')
-  assert.equal(s.hour(), 14, '.hour()')
-  assert.equal(s.minute(), 20, '.minute()')
+  t.equal(s.hour(), 14, '.hour()')
+  t.equal(s.minute(), 20, '.minute()')
+  t.end()
 })
 
-test('day-tricky', () => {
+test('day-tricky', (t) => {
   let d = spacetime('2019-11-04T00:00:00.000', 'Canada/Eastern')
   d = d.add(1, 'week')
-  assert.equal(d.format('nice-day'), 'Mon Nov 11th', 'add week over dst-change')
+  t.equal(d.format('nice-day'), 'Mon Nov 11th', 'add week over dst-change')
 
   //same thing, but days
   d = spacetime('2019-11-04T00:00:00.000', 'Canada/Eastern')
   d = d.add(7, 'days')
-  assert.equal(d.format('nice-day'), 'Mon Nov 11th', 'add days over dst-change')
+  t.equal(d.format('nice-day'), 'Mon Nov 11th', 'add days over dst-change')
 
   d = spacetime('2021-10-31T00:00:00.000', 'Europe/London')
   d = d.add(1, 'day')
-  assert.equal(d.format('iso-utc'), '2021-11-01T00:00:00.000Z', 'add 1 day over dst-change')
+  t.equal(d.format('iso-utc'), '2021-11-01T00:00:00.000Z', 'add 1 day over dst-change')
 
   // add day over month-change
   let s = spacetime('Oct 31 2020', 'Canada/Eastern')
   s = s.add(2, 'day')
-  assert.equal(s.format('nice'), 'Nov 2nd, 12:00am', 'add day over month-change')
+  t.equal(s.format('nice'), 'Nov 2nd, 12:00am', 'add day over month-change')
   // add day over year-change
   s = spacetime('Dec 31 2020', 'Canada/Eastern')
   s = s.add(2, 'day')
-  assert.equal(s.format('nice'), 'Jan 2nd, 12:00am', 'add day over year-change')
+  t.equal(s.format('nice'), 'Jan 2nd, 12:00am', 'add day over year-change')
 
+  t.end()
 })
 
-test('new-years-eve', () => {
+test('new-years-eve', (t) => {
   let year = 2022
   let nye = spacetime(`2022-01-01T00:00:00.000Z`)
   for (let i = 0; i < 20; i += 1) {
     nye = nye.minus(1, 'year')
     year -= 1
-    assert.equal(nye.format(), `${year}-01-01`, `${year} exact millisecond`)
+    t.equal(nye.format(), `${year}-01-01`, `${year} exact millisecond`)
   }
+  t.end()
 })
 
-test('add-weekend', () => {
+test('add-weekend', (t) => {
   let d = spacetime('2021-04-17')
   d = d.add(1, 'weekend')
-  assert.equal(d.dayName(), 'saturday', 'is saturday')
-  assert.equal(d.format('iso-short'), '2021-04-24', 'is ahead')
+  t.equal(d.dayName(), 'saturday', 'is saturday')
+  t.equal(d.format('iso-short'), '2021-04-24', 'is ahead')
+  t.end()
 })
 
-test('add-30-years', () => {
+test('add-30-years', (t) => {
   let d = spacetime('2000-01-01 00:00:00')
   d = d.add(30, 'year')
-  assert.equal(d.format('iso-short'), '2030-01-01', 'plus 30 years')
+  t.equal(d.format('iso-short'), '2030-01-01', 'plus 30 years')
+  t.end()
 })
 
-test('year-tricky', () => {
+test('year-tricky', (t) => {
   const s = spacetime(1451667600000, 'Canada/Eastern') //jan 1 2016 (leap year)
-  assert.equal(s.year(), 2016, 'year1')
+  t.equal(s.year(), 2016, 'year1')
 
   const a = s.clone().add(1, 'year')
-  assert.equal(a.year(), 2017, 'year-next')
+  t.equal(a.year(), 2017, 'year-next')
 
   const b = s.clone().subtract(1, 'year')
-  assert.equal(b.year(), 2015, 'year-last')
+  t.equal(b.year(), 2015, 'year-last')
+  t.end()
 })

scripts/testReporter.js

@@ -1,6 +1,5 @@
 import spacetime from './lib/index.js'
-import { test } from 'node:test'
-import assert from './lib/assert.js'
+import test from 'tape'
 import api from '../api/index.js'
 
 const instanceSections = ['main', 'getters', 'utils']
@@ -32,24 +31,26 @@ const staticUndocumented = new Set([
 ])
 
 // every documented instance method should actually exist as a function
-test('documented instance methods exist', () => {
+test('documented instance methods exist', (t) => {
   const s = spacetime('1998-03-28')
   instanceSections.forEach((section) => {
     Object.keys(api[section]).forEach((k) => {
-      assert.equal(typeof s[k], 'function', `${section}.${k} exists`)
+      t.equal(typeof s[k], 'function', `${section}.${k} exists`)
     })
   })
+  t.end()
 })
 
 // every documented static method should actually exist as a function
-test('documented static methods exist', () => {
+test('documented static methods exist', (t) => {
   Object.keys(api.statics).forEach((k) => {
-    assert.equal(typeof spacetime[k], 'function', `statics.${k} exists`)
+    t.equal(typeof spacetime[k], 'function', `statics.${k} exists`)
   })
+  t.end()
 })
 
 // every public instance method should be documented (catches docs falling behind the code)
-test('public instance methods are documented', () => {
+test('public instance methods are documented', (t) => {
   const s = spacetime('1998-03-28')
   const documented = new Set(instanceSections.flatMap((section) => Object.keys(api[section])))
   const proto = Object.getPrototypeOf(s)
@@ -59,19 +60,21 @@ test('public instance methods are documented', () => {
       if (undocumented.has(k)) {
         return
       }
-      assert.ok(documented.has(k), `${k} is documented in api/index.js`)
+      t.ok(documented.has(k), `${k} is documented in api/index.js`)
     })
+  t.end()
 })
 
 // every public static method should be documented
-test('public static methods are documented', () => {
+test('public static methods are documented', (t) => {
   const documented = new Set(Object.keys(api.statics))
   Object.getOwnPropertyNames(spacetime)
     .filter((k) => !['length', 'name', 'prototype'].includes(k) && typeof spacetime[k] === 'function')
     .forEach((k) => {
       if (staticUndocumented.has(k)) {
         return
       }
-      assert.ok(documented.has(k), `spacetime.${k} is documented in api/index.js`)
+      t.ok(documented.has(k), `spacetime.${k} is documented in api/index.js`)
     })
+  t.end()
 })

test/add.test.js

@@ -1,20 +1,20 @@
-import { test } from 'node:test'
-import assert from './lib/assert.js'
+import test from 'tape'
 import spacetime from './lib/index.js'
 
-test('clone', () => {
+test('clone', (t) => {
   let a = spacetime('March 18, 1999 23:42:00', 'Canada/Eastern')
   let b = a.clone()
-  assert.equal(a.date(), 18, 'start-date')
-  assert.equal(a.hour(), 23, 'start hour')
-  assert.equal(a.isSame(b, 'hour'), true, 'same-hour')
+  t.equal(a.date(), 18, 'start-date')
+  t.equal(a.hour(), 23, 'start hour')
+  t.equal(a.isSame(b, 'hour'), true, 'same-hour')
 
   a = a.hour(7)
-  assert.equal(a.hour(), 7, 'new-hour')
-  assert.equal(b.hour(), 23, 'old-hour')
+  t.equal(a.hour(), 7, 'new-hour')
+  t.equal(b.hour(), 23, 'old-hour')
 
   b = b.date(17)
-  assert.equal(b.date(), 17, 'new-date')
-  assert.equal(a.date(), 18, 'old-date')
+  t.equal(b.date(), 17, 'new-date')
+  t.equal(a.date(), 18, 'old-date')
 
+  t.end()
 })