@tak-ps/node-tak 12.8.0 → 12.10.0

package/test/pipeline.test.ts

@@ -1,4 +1,5 @@
-import test from 'tape';
+import test from 'node:test';
+import assert from 'node:assert/strict';
 import { EventEmitter } from 'node:events';
 import TAK, { CoT } from '../index.js';
 import { CoTParser } from '@tak-ps/node-cot';
@@ -20,26 +21,24 @@ function createFakeSocket(opts: { write?: (...args: unknown[]) => boolean } = {}
     });
 }
 
-test('write - resolves when all CoTs are queued and sent', async (t) => {
+test('write - resolves when all CoTs are queued and sent', async () => {
     const tak = createTAK();
     tak.client = createFakeSocket();
 
     const cots = [CoT.ping(), CoT.ping()];
     await tak.write(cots);
 
-    t.equals(tak.queue.length, 0, 'queue empty after write + pull');
-    t.end();
+    assert.equal(tak.queue.length, 0, 'queue empty after write + pull');
 });
 
-test('write - returns early when destroyed', async (t) => {
+test('write - returns early when destroyed', async () => {
     const tak = createTAK();
     tak.destroyed = true;
     await tak.write([CoT.ping()]);
-    t.equals(tak.queue.length, 0, 'nothing queued');
-    t.end();
+    assert.equal(tak.queue.length, 0, 'nothing queued');
 });
 
-test('write - multiple concurrent writes', async (t) => {
+test('write - multiple concurrent writes', async () => {
     const tak = createTAK();
     tak.client = createFakeSocket();
 
@@ -48,12 +47,11 @@ test('write - multiple concurrent writes', async (t) => {
     const p2 = tak.write([CoT.ping()]).then(() => order.push(2));
     await Promise.all([p1, p2]);
 
-    t.deepEquals(order, [1, 2], 'writes resolve in order');
-    t.equals(tak.queue.length, 0, 'queue drained');
-    t.end();
+    assert.deepEqual(order, [1, 2], 'writes resolve in order');
+    assert.equal(tak.queue.length, 0, 'queue drained');
 });
 
-test('pull - batches CoTs into single socket.write call', async (t) => {
+test('pull - batches CoTs into single socket.write call', async () => {
     const tak = createTAK({ socketBatchSize: 64 });
     const writeCalls: string[] = [];
     tak.client = createFakeSocket({
@@ -65,13 +63,12 @@ test('pull - batches CoTs into single socket.write call', async (t) => {
 
     await tak.write([CoT.ping(), CoT.ping()]);
 
-    t.equals(writeCalls.length, 1, 'socket.write called once for batch');
-    t.ok(writeCalls[0].includes('<event'), 'batch contains XML events');
-    t.equals(tak.queue.length, 0, 'queue drained');
-    t.end();
+    assert.equal(writeCalls.length, 1, 'socket.write called once for batch');
+    assert.ok(writeCalls[0].includes('<event'), 'batch contains XML events');
+    assert.equal(tak.queue.length, 0, 'queue drained');
 });
 
-test('pull - respects backpressure and resumes on process()', async (t) => {
+test('pull - respects backpressure and resumes on process()', async () => {
     const tak = createTAK({ socketBatchSize: 1 });
     let callCount = 0;
     const socket = createFakeSocket({
@@ -89,19 +86,18 @@ test('pull - respects backpressure and resumes on process()', async (t) => {
     // Both CoTs get queued immediately, pull() sends 1 and hits backpressure
     await tak.write([CoT.ping(), CoT.ping()]);
 
-    t.equals(callCount, 1, 'one write before backpressure');
-    t.equals(tak.queue.length, 1, 'one item still in queue');
+    assert.equal(callCount, 1, 'one write before backpressure');
+    assert.equal(tak.queue.length, 1, 'one item still in queue');
 
     // Simulate backpressure clearing (equivalent to drain event)
     socket.writableNeedDrain = false;
     tak.process();
 
-    t.equals(callCount, 2, 'second write after backpressure cleared');
-    t.equals(tak.queue.length, 0, 'queue drained');
-    t.end();
+    assert.equal(callCount, 2, 'second write after backpressure cleared');
+    assert.equal(tak.queue.length, 0, 'queue drained');
 });
 
-test('pull - error in socket.write triggers destroy + error event', async (t) => {
+test('pull - error in socket.write triggers destroy + error event', async () => {
     const tak = createTAK();
     tak.client = createFakeSocket({
         write() { throw new Error('write failed'); },
@@ -115,13 +111,12 @@ test('pull - error in socket.write triggers destroy + error event', async (t) =>
     // write() sees destroyed=true on next check and returns
     await tak.write([CoT.ping()]);
 
-    t.equals(tak.destroyed, true, 'destroyed after write error');
-    t.ok(errorFired, 'error event fired');
-    t.equals(errorMsg, 'write failed', 'error message matches');
-    t.end();
+    assert.equal(tak.destroyed, true, 'destroyed after write error');
+    assert.ok(errorFired, 'error event fired');
+    assert.equal(errorMsg, 'write failed', 'error message matches');
 });
 
-test('pull - noop when already writing', (t) => {
+test('pull - noop when already writing', () => {
     const tak = createTAK();
     tak.client = createFakeSocket();
     tak.writing = true;
@@ -131,18 +126,16 @@ test('pull - noop when already writing', (t) => {
     // pull() should return immediately since writing=true
     tak.process();
 
-    t.equals(tak.queue.length, 1, 'queue unchanged');
-    t.end();
+    assert.equal(tak.queue.length, 1, 'queue unchanged');
 });
 
-test('flush - resolves immediately when nothing queued', async (t) => {
+test('flush - resolves immediately when nothing queued', async () => {
     const tak = createTAK();
     await tak.flush();
-    t.pass('flush resolved immediately');
-    t.end();
+    assert.ok(true, 'flush resolved immediately');
 });
 
-test('flush - rejects when destroyed mid-flush', async (t) => {
+test('flush - rejects when destroyed mid-flush', async () => {
     const tak = createTAK();
     tak.client = createFakeSocket();
 
@@ -155,15 +148,14 @@ test('flush - rejects when destroyed mid-flush', async (t) => {
 
     try {
         await p;
-        t.fail('should have rejected');
+        assert.fail('should have rejected');
     } catch (err) {
-        t.ok(err instanceof Error, 'error is an Error');
-        t.ok((err as Error).message.includes('destroyed'), 'error mentions destroyed');
+        assert.ok(err instanceof Error, 'error is an Error');
+        assert.ok((err as Error).message.includes('destroyed'), 'error mentions destroyed');
     }
-    t.end();
 });
 
-test('flush - waits for queue to drain via process()', async (t) => {
+test('flush - waits for queue to drain via process()', async () => {
     const tak = createTAK({ socketBatchSize: 1 });
     let callCount = 0;
     const socket = createFakeSocket({
@@ -179,7 +171,7 @@ test('flush - waits for queue to drain via process()', async (t) => {
     tak.client = socket;
 
     await tak.write([CoT.ping(), CoT.ping()]);
-    t.equals(tak.queue.length, 1, 'one item in queue after backpressure');
+    assert.equal(tak.queue.length, 1, 'one item in queue after backpressure');
 
     // Clear backpressure and drain
     socket.writableNeedDrain = false;
@@ -187,12 +179,11 @@ test('flush - waits for queue to drain via process()', async (t) => {
     tak.process();
     await flushP;
 
-    t.equals(tak.queue.length, 0, 'queue empty after flush');
-    t.equals(callCount, 2, 'both items sent');
-    t.end();
+    assert.equal(tak.queue.length, 0, 'queue empty after flush');
+    assert.equal(callCount, 2, 'both items sent');
 });
 
-test('write - yields when queue is full and resumes after destroy', async (t) => {
+test('write - yields when queue is full and resumes after destroy', async () => {
     // writeQueueSize=4 → queue capacity = 4
     const tak = createTAK({ writeQueueSize: 4 });
 
@@ -202,17 +193,16 @@ test('write - yields when queue is full and resumes after destroy', async (t) =>
         .then(() => { writeResolved = true; });
     await new Promise(r => setImmediate(r));
 
-    t.equals(tak.queue.length, 4, 'queue at capacity');
-    t.equals(writeResolved, false, 'write blocked waiting for space');
+    assert.equal(tak.queue.length, 4, 'queue at capacity');
+    assert.equal(writeResolved, false, 'write blocked waiting for space');
 
     // Destroy unblocks write (destroyed check in loop)
     tak.destroy();
     await p;
-    t.ok(writeResolved, 'write resolved after destroy');
-    t.end();
+    assert.ok(writeResolved, 'write resolved after destroy');
 });
 
-test('write - resumes after queue drains', async (t) => {
+test('write - resumes after queue drains', async () => {
     // writeQueueSize=8 → queue capacity = 8, socketBatchSize=4
     const tak = createTAK({ writeQueueSize: 8, socketBatchSize: 4 });
     let callCount = 0;
@@ -230,12 +220,11 @@ test('write - resumes after queue drains', async (t) => {
         CoT.ping(), CoT.ping(), CoT.ping(), CoT.ping(), CoT.ping(),
     ]);
 
-    t.equals(tak.queue.length, 0, 'all drained');
-    t.ok(callCount >= 2, 'multiple socket.write calls needed');
-    t.end();
+    assert.equal(tak.queue.length, 0, 'all drained');
+    assert.ok(callCount >= 2, 'multiple socket.write calls needed');
 });
 
-test('write - caller can safely modify array after write returns', async (t) => {
+test('write - caller can safely modify array after write returns', async () => {
     const tak = createTAK();
     const writeCalls: string[] = [];
     tak.client = createFakeSocket({
@@ -251,13 +240,12 @@ test('write - caller can safely modify array after write returns', async (t) =>
     // Modify the array after write — should not affect what was sent
     cots.length = 0;
 
-    t.equals(writeCalls.length, 1, 'socket.write was called');
-    t.ok(writeCalls[0].includes('<event'), 'CoT was sent before array was cleared');
-    t.equals(tak.queue.length, 0, 'queue empty');
-    t.end();
+    assert.equal(writeCalls.length, 1, 'socket.write was called');
+    assert.ok(writeCalls[0].includes('<event'), 'CoT was sent before array was cleared');
+    assert.equal(tak.queue.length, 0, 'queue empty');
 });
 
-test('write - stripFlow replaces existing flow tags in outbound XML', async (t) => {
+test('write - stripFlow replaces existing flow tags in outbound XML', async () => {
     const tak = createTAK();
     const writeCalls: string[] = [];
     tak.client = createFakeSocket({
@@ -292,30 +280,27 @@ test('write - stripFlow replaces existing flow tags in outbound XML', async (t)
 
     await tak.write([cot], { stripFlow: true });
 
-    t.equals(writeCalls.length, 1, 'socket.write was called');
-    t.notOk(writeCalls[0].includes('TAK-Server-test='), 'server flow tag removed from outbound XML');
-    t.ok(writeCalls[0].includes('NodeCoT-'), 'node-cot flow tag added to outbound XML');
+    assert.equal(writeCalls.length, 1, 'socket.write was called');
+    assert.ok(!writeCalls[0].includes('TAK-Server-test='), 'server flow tag removed from outbound XML');
+    assert.ok(writeCalls[0].includes('NodeCoT-'), 'node-cot flow tag added to outbound XML');
 
     const outbound = CoTParser.from_xml(writeCalls[0]);
     const outboundFlow = outbound.raw.event.detail?.['_flow-tags_'];
 
-    t.ok(outboundFlow, 'outbound CoT contains flow tags');
-    t.equal(Object.keys(outboundFlow || {}).length, 1, 'outbound CoT flow object is reset to one initial tag');
-    t.notOk(outboundFlow?.['TAK-Server-test'], 'outbound CoT flow object clears prior TAK Server tags');
+    assert.ok(outboundFlow, 'outbound CoT contains flow tags');
+    assert.equal(Object.keys(outboundFlow || {}).length, 1, 'outbound CoT flow object is reset to one initial tag');
+    assert.ok(!outboundFlow?.['TAK-Server-test'], 'outbound CoT flow object clears prior TAK Server tags');
 
     const feat = await CoTParser.to_geojson(cot);
-    t.equal(feat.properties.flow?.['TAK-Server-test'], '2026-03-08T04:48:00Z', 'original CoT remains unchanged');
-
-    t.end();
+    assert.equal(feat.properties.flow?.['TAK-Server-test'], '2026-03-08T04:48:00Z', 'original CoT remains unchanged');
 });
 
-test('destroy - sets destroyed and clears ping interval', (t) => {
+test('destroy - sets destroyed and clears ping interval', () => {
     const tak = createTAK();
     tak.pingInterval = setInterval(() => {}, 60000);
 
     tak.destroy();
 
-    t.equals(tak.destroyed, true, 'destroyed is true');
-    t.equals(tak.pingInterval, undefined, 'pingInterval cleared');
-    t.end();
+    assert.equal(tak.destroyed, true, 'destroyed is true');
+    assert.equal(tak.pingInterval, undefined, 'pingInterval cleared');
 });

package/test/queue.test.ts

@@ -1,49 +1,46 @@
-import test from 'tape';
+import test from 'node:test';
+import assert from 'node:assert/strict';
 import { Queue } from '../lib/utils/queue.js';
 
-test('Queue - push/pop FIFO order', (t) => {
+test('Queue - push/pop FIFO order', () => {
     const q = new Queue<number>(4);
     q.push(1);
     q.push(2);
     q.push(3);
-    t.equals(q.pop(), 1);
-    t.equals(q.pop(), 2);
-    t.equals(q.pop(), 3);
-    t.end();
+    assert.equal(q.pop(), 1);
+    assert.equal(q.pop(), 2);
+    assert.equal(q.pop(), 3);
 });
 
-test('Queue - capacity enforced', (t) => {
+test('Queue - capacity enforced', () => {
     const q = new Queue<number>(2);
-    t.equals(q.push(1), true);
-    t.equals(q.push(2), true);
-    t.equals(q.isFull, true);
-    t.equals(q.push(3), false);
-    t.equals(q.length, 2);
-    t.end();
+    assert.equal(q.push(1), true);
+    assert.equal(q.push(2), true);
+    assert.equal(q.isFull, true);
+    assert.equal(q.push(3), false);
+    assert.equal(q.length, 2);
 });
 
-test('Queue - pop from empty', (t) => {
+test('Queue - pop from empty', () => {
     const q = new Queue<number>(2);
-    t.equals(q.pop(), undefined);
-    t.equals(q.length, 0);
-    t.end();
+    assert.equal(q.pop(), undefined);
+    assert.equal(q.length, 0);
 });
 
-test('Queue - ring buffer wraparound', (t) => {
+test('Queue - ring buffer wraparound', () => {
     const q = new Queue<number>(3);
     q.push(1);
     q.push(2);
     q.push(3);
     // Pop two — head advances past midpoint
-    t.equals(q.pop(), 1);
-    t.equals(q.pop(), 2);
+    assert.equal(q.pop(), 1);
+    assert.equal(q.pop(), 2);
     // Push two more — tail wraps around
     q.push(4);
     q.push(5);
     // Remaining items come out in FIFO order
-    t.equals(q.pop(), 3);
-    t.equals(q.pop(), 4);
-    t.equals(q.pop(), 5);
-    t.equals(q.length, 0);
-    t.end();
+    assert.equal(q.pop(), 3);
+    assert.equal(q.pop(), 4);
+    assert.equal(q.pop(), 5);
+    assert.equal(q.length, 0);
 });

package/test/uploadPackage.test.ts

@@ -0,0 +1,62 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { Readable } from 'node:stream';
+import { Client } from 'undici';
+import type { IncomingHttpHeaders } from 'node:http';
+import type { Dispatcher } from 'undici';
+import TAKAPI from '../lib/api.js';
+import { APIAuthCertificate } from '../lib/auth.js';
+import stream2buffer from '../lib/stream.js';
+
+type RequestArgs = Parameters<Client['request']>[0];
+
+test('Files.uploadPackage serializes multipart for certificate auth', async () => {
+    const originalRequest = Client.prototype.request;
+
+    let captured: RequestArgs | undefined;
+
+    Client.prototype.request = async function(opts: RequestArgs): Promise<Dispatcher.ResponseData> {
+        captured = opts;
+
+        return {
+            statusCode: 200,
+            headers: {
+                'content-type': 'text/plain'
+            },
+            body: Readable.from([Buffer.from('ok')]),
+            trailers: {}
+        } as unknown as Dispatcher.ResponseData;
+    };
+
+    try {
+        const api = new TAKAPI(new URL('https://tak.example.com'), new APIAuthCertificate('cert', 'key'));
+
+        const res = await api.Files.uploadPackage({
+            name: 'mission.zip',
+            creatorUid: 'user-1',
+            hash: 'hash-123',
+            keywords: ['alpha'],
+            groups: ['Blue']
+        }, Buffer.from('zip-bytes'));
+
+        assert.equal(res, 'ok');
+        assert.ok(captured);
+        assert.equal(captured.path, '/Marti/sync/missionupload?filename=mission.zip&creatorUid=user-1&hash=hash-123&keyword=missionpackage&keyword=alpha&Groups=Blue');
+        const headers = captured.headers as IncomingHttpHeaders;
+        assert.equal(typeof headers['Content-Type'], 'string');
+        assert.equal(typeof headers['Content-Length'], 'string');
+        assert.match(headers['Content-Type'] as string, /^multipart\/form-data; boundary=----node-tak-/);
+        assert.equal(Number(headers['Content-Length']) > 0, true);
+
+        assert.ok(captured.body instanceof Readable);
+        const body = await stream2buffer(captured.body);
+        const multipart = body.toString('utf8');
+
+        assert.match(multipart, /Content-Disposition: form-data; name="assetfile"; filename="mission.zip"/);
+        assert.match(multipart, /Content-Type: application\/zip/);
+        assert.match(multipart, /zip-bytes/);
+        assert.match(multipart, /--$/m);
+    } finally {
+        Client.prototype.request = originalRequest;
+    }
+});