Update CHANGELOG

Author: ingalls

CHANGELOG.md

@@ -12,6 +12,10 @@
 
 ### Pending Fixed
 
+### v14.34.0 - 2025-04-13
+
+- :arrow_up: Remove `tape` in favor of `node:test` for unit tests
+
 ### v14.33.0 - 2025-04-11
 
 - :rocket: `creator.callsign` property is optional

package-lock.json

@@ -58,10 +58,8 @@
     "devDependencies": {
         "@eslint/js": "^10.0.1",
         "@types/node": "^25.0.0",
-        "@types/tape": "^5.6.0",
         "c8": "^11.0.0",
         "eslint": "^10.0.0",
-        "tape": "^5.6.1",
         "tsx": "^4.20.3",
         "typedoc": "^0.28.0",
         "typescript": "^6.0.0",

package.json

@@ -1,86 +1,80 @@
-import test from 'tape';
+import assert from 'node:assert/strict';
+import test from 'node:test';
 import MilSymType, { StandardIdentity } from '../lib/utils/2525.js';
 
-test('2525 StandardIdentity', (t) => {
-    t.equal(
+test('2525 StandardIdentity', () => {
+    assert.equal(
         MilSymType.standardIdentity('b-f-D'),
         StandardIdentity.NONE
     );
 
-    t.equal(
+    assert.equal(
         MilSymType.standardIdentity('a-'),
         StandardIdentity.NONE
     );
 
-    t.equal(
+    assert.equal(
         MilSymType.standardIdentity('a-x-D-H'),
         StandardIdentity.NONE
     );
 
-    t.equal(
+    assert.equal(
         MilSymType.standardIdentity('a-h-S'),
         StandardIdentity.HOSTILE
     );
-
-    t.end();
 });
 
-test('2525 <=> SIDC to2525B', (t) => {
-    t.equals("SHSPCLDD-------", MilSymType.to2525B("a-h-S-C-L-D-D"))
-    t.equals("SFGPUCVRA------", MilSymType.to2525B("a-f-G-U-C-V-R-A"))
+test('2525 <=> SIDC to2525B', () => {
+    assert.equal("SHSPCLDD-------", MilSymType.to2525B("a-h-S-C-L-D-D"))
+    assert.equal("SFGPUCVRA------", MilSymType.to2525B("a-f-G-U-C-V-R-A"))
 
-    t.throws(() => {
+    assert.throws(() => {
         MilSymType.to2525B("b-h-S-C-L-D-D")
     }, /CoT to 2525B can only be applied to well-formed Atom type CoT Events./);
 
-    t.throws(() => {
+    assert.throws(() => {
         MilSymType.to2525B("")
     }, /CoT to 2525B can only be applied to well-formed Atom type CoT Events./);
 
-    t.throws(() => {
+    assert.throws(() => {
         MilSymType.to2525B("bhSCLDD")
     }, /CoT to 2525B can only be applied to well-formed Atom type CoT Events./);
 
-    t.throws(() => {
+    assert.throws(() => {
         MilSymType.to2525B("b-h-s-c-l-d-d")
     }, /CoT to 2525B can only be applied to well-formed Atom type CoT Events./);
 
-    t.throws(() => {
+    assert.throws(() => {
         MilSymType.to2525B("b-h-S-?-L-D-D")
     }, /CoT to 2525B can only be applied to well-formed Atom type CoT Events./);
-
-    t.end();
 });
 
-test('2525 <=> SIDC from2525B', (t) => {
+test('2525 <=> SIDC from2525B', () => {
 
-    t.equal("a-h-S-C-L-D-D", MilSymType.from2525B("SHSPCLDD-------"))
-    t.equal("a-f-G-U-C-V-R-A", MilSymType.from2525B("SFGPUCVRA------"))
+    assert.equal("a-h-S-C-L-D-D", MilSymType.from2525B("SHSPCLDD-------"))
+    assert.equal("a-f-G-U-C-V-R-A", MilSymType.from2525B("SFGPUCVRA------"))
 
-    t.throws(() => {
+    assert.throws(() => {
         MilSymType.from2525B("SFGPUCVRA")
     }, /2525B to CoT can only be applied to well-formed warfighting 2525B SIDCs./);
 
-    t.throws(() => {
+    assert.throws(() => {
         MilSymType.from2525B("SOGPUCVRA------")
     }, /2525B to CoT can only be applied to well-formed warfighting 2525B SIDCs./);
 
-    t.throws(() => {
+    assert.throws(() => {
         MilSymType.from2525B("SFMPUCVRA------")
     }, /2525B to CoT can only be applied to well-formed warfighting 2525B SIDCs./);
 
-    t.throws(() => {
+    assert.throws(() => {
         MilSymType.from2525B("SFMPUCVRA------")
     }, /2525B to CoT can only be applied to well-formed warfighting 2525B SIDCs./);
 
-    t.throws(() => {
+    assert.throws(() => {
         MilSymType.from2525B("SFGP*CVRA------")
     }, /2525B to CoT can only be applied to well-formed warfighting 2525B SIDCs./);
 
-    t.throws(() => {
+    assert.throws(() => {
         MilSymType.from2525B("GFGPUCVRA------")
     }, /2525B to CoT can only be applied to well-formed warfighting 2525B SIDCs./);
-
-
-    t.end();
 })

test/2525.test.ts

@@ -1,24 +1,25 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import test from 'tape';
+import assert from 'node:assert/strict';
+import test from 'node:test';
 import { Basemap } from '../index.js';
 import { fileURLToPath } from 'node:url';
 
 for (const fixturename of await fs.readdir(new URL('./basemaps/', import.meta.url))) {
-    test(`Basemap Test: ${fixturename}`, async (t) => {
+    test(`Basemap Test: ${fixturename}`, async () => {
         const fixture = String(await fs.readFile(path.join(path.parse(fileURLToPath(import.meta.url)).dir, 'basemaps/', fixturename)));
         const container = await Basemap.parse(fixture);
 
-        t.ok(container.raw.customMapSource.name._text.length, 'Ensure raw xml name exists')
+        assert.ok(container.raw.customMapSource.name._text.length, 'Ensure raw xml name exists')
 
         const json = container.to_json();
-        t.ok(json.name && json.name.length, 'Ensure JSON name exists');
-        t.ok(json.url && json.url.length, 'Ensure JSON url exists');
-        t.ok(typeof json.minZoom === 'number', 'Ensure JSON minZoom is a number');
-        t.ok(typeof json.maxZoom === 'number', 'Ensure JSON maxZoom is a number');
-        t.ok(typeof json.tileType === 'string' && json.tileType.length, 'Ensure JSON tileType is a string');
+        assert.ok(json.name && json.name.length, 'Ensure JSON name exists');
+        assert.ok(json.url && json.url.length, 'Ensure JSON url exists');
+        assert.ok(typeof json.minZoom === 'number', 'Ensure JSON minZoom is a number');
+        assert.ok(typeof json.maxZoom === 'number', 'Ensure JSON maxZoom is a number');
+        assert.ok(typeof json.tileType === 'string' && json.tileType.length, 'Ensure JSON tileType is a string');
 
-        t.deepEqual(Object.keys(json), [
+        assert.deepEqual(Object.keys(json), [
             'name',
             'url',
             'minZoom',
@@ -28,7 +29,5 @@ for (const fixturename of await fs.readdir(new URL('./basemaps/', import.meta.ur
             'backgroundColor',
             'serverParts'
         ], 'Ensure JSON keys match expected structure')
-
-        t.end();
     });
 }

test/basemaps.test.ts

@@ -1,7 +1,8 @@
-import test from 'tape';
+import assert from 'node:assert/strict';
+import test from 'node:test';
 import { CoTParser } from '../index.js';
 
-test('COT.callsign', async (t) => {
+test('COT.callsign', async () => {
     const cot = await CoTParser.from_geojson({
         "id": "123",
         "type": "Feature",
@@ -22,14 +23,12 @@ test('COT.callsign', async (t) => {
         }
     });
 
-    t.equals(cot.callsign(), 'BasicTest');
-    t.equals(cot.callsign('Reassign'), 'Reassign');
-    t.equals(cot.callsign(), 'Reassign');
-
-    t.end();
+    assert.equal(cot.callsign(), 'BasicTest');
+    assert.equal(cot.callsign('Reassign'), 'Reassign');
+    assert.equal(cot.callsign(), 'Reassign');
 });
 
-test('COT.type', async (t) => {
+test('COT.type', async () => {
     const cot = await CoTParser.from_geojson({
         "id": "123",
         "type": "Feature",
@@ -50,14 +49,12 @@ test('COT.type', async (t) => {
         }
     });
 
-    t.equals(cot.type(), 'a-f-G');
-    t.equals(cot.type('u-d-f'), 'u-d-f');
-    t.equals(cot.type(), 'u-d-f');
-
-    t.end();
+    assert.equal(cot.type(), 'a-f-G');
+    assert.equal(cot.type('u-d-f'), 'u-d-f');
+    assert.equal(cot.type(), 'u-d-f');
 });
 
-test('COT.archived', async (t) => {
+test('COT.archived', async () => {
     const cot = await CoTParser.from_geojson({
         "id": "123",
         "type": "Feature",
@@ -78,17 +75,15 @@ test('COT.archived', async (t) => {
         }
     });
 
-    t.equals(cot.archived(), false);
-    t.equals(cot.archived(true), true);
-
-    t.equals((await CoTParser.to_geojson(cot)).properties.archived, true)
+    assert.equal(cot.archived(), false);
+    assert.equal(cot.archived(true), true);
 
-    t.equals(cot.archived(), true);
-    t.equals(cot.archived(false), false);
-    t.equals(cot.archived(), false);
+    assert.equal((await CoTParser.to_geojson(cot)).properties.archived, true)
 
-    t.equals((await CoTParser.to_geojson(cot)).properties.archived, undefined)
+    assert.equal(cot.archived(), true);
+    assert.equal(cot.archived(false), false);
+    assert.equal(cot.archived(), false);
 
-    t.end();
+    assert.equal((await CoTParser.to_geojson(cot)).properties.archived, undefined)
 });
 

test/basic.test.ts

@@ -1,7 +1,8 @@
-import test from 'tape';
+import assert from 'node:assert/strict';
+import test from 'node:test';
 import { DirectChat, MissionChat, CoTParser } from '../index.js';
 
-test('MissionChat - GeoJSON output', async (t) => {
+test('MissionChat - GeoJSON output', async () => {
     const messageId = '6c19bcd5-c632-4c59-95e2-ae8c76c8feab';
 
     const cot = new MissionChat({
@@ -32,7 +33,7 @@ test('MissionChat - GeoJSON output', async (t) => {
     cot.raw.event.point._attributes.lat = 39.078503;
     cot.raw.event.point._attributes.hae = 1393.296;
 
-    t.deepEquals(await CoTParser.to_geojson(cot), {
+    assert.deepEqual(await CoTParser.to_geojson(cot), {
         id: `GeoChat.ANDROID-764679f74013dfe2.ops.cotak.gov-8443-ssl-Test Attachments.${messageId}`,
         type: 'Feature',
         path: '/',
@@ -73,11 +74,9 @@ test('MissionChat - GeoJSON output', async (t) => {
             coordinates: [ -108.537452, 39.078503, 1393.296 ]
         }
     });
-
-    t.end();
 });
 
-test('DirectChat - Basic', (t) => {
+test('DirectChat - Basic', () => {
     const cot = new DirectChat({
         to: {
             uid: '123456',
@@ -90,36 +89,36 @@ test('DirectChat - Basic', (t) => {
         message: 'Direct Message Test'
     });
 
-    t.equals(cot.is_chat(), true);
+    assert.equal(cot.is_chat(), true);
 
-    t.ok(cot.raw.event._attributes.uid);
+    assert.ok(cot.raw.event._attributes.uid);
     cot.raw.event._attributes.uid = '123';
 
     if (!cot.raw.event.detail) {
-        t.fail('No Detail Section')
+        assert.fail('No Detail Section')
     } else {
-        t.equals(typeof cot.raw.event._attributes.time, 'string');
+        assert.equal(typeof cot.raw.event._attributes.time, 'string');
         cot.raw.event._attributes.time = '2024-04-01'
-        t.equals(typeof cot.raw.event._attributes.start, 'string');
+        assert.equal(typeof cot.raw.event._attributes.start, 'string');
         cot.raw.event._attributes.start = '2024-04-01'
-        t.equals(typeof cot.raw.event._attributes.stale, 'string');
+        assert.equal(typeof cot.raw.event._attributes.stale, 'string');
         cot.raw.event._attributes.stale = '2024-04-01'
 
         if (!cot.raw.event.detail.__chat) {
-            t.fail('No Chat Section')
+            assert.fail('No Chat Section')
         } else {
-            t.equals(typeof cot.raw.event.detail.__chat._attributes.messageId, 'string');
+            assert.equal(typeof cot.raw.event.detail.__chat._attributes.messageId, 'string');
             cot.raw.event.detail.__chat._attributes.messageId = '123';
         }
 
         if (!cot.raw.event.detail.remarks || !cot.raw.event.detail.remarks._attributes) {
-            t.fail('No Remarks Section')
+            assert.fail('No Remarks Section')
         } else {
-            t.equals(typeof cot.raw.event.detail.remarks._attributes.time, 'string');
+            assert.equal(typeof cot.raw.event.detail.remarks._attributes.time, 'string');
             cot.raw.event.detail.remarks._attributes.time = '123';
         }
 
-        t.deepEquals(cot.raw, {
+        assert.deepEqual(cot.raw, {
             event: {
                 _attributes: {
                     uid: '123',
@@ -178,6 +177,4 @@ test('DirectChat - Basic', (t) => {
             }
         });
     }
-
-    t.end();
 });