71 lines
2.3 KiB
TypeScript
71 lines
2.3 KiB
TypeScript
import { expect, expectAsync, tap } from '@push.rocks/tapbundle';
|
|
import * as webstream from '../ts_web/index.js';
|
|
|
|
tap.test('WebDuplexStream', async (toolsArg) => {
|
|
const testDone = toolsArg.defer(); // Create a deferred object to control test completion.
|
|
const inputUint8Array = new Uint8Array([1, 2, 3, 4, 5]);
|
|
const stream = webstream.WebDuplexStream.fromUInt8Array(inputUint8Array);
|
|
|
|
const reader = stream.readable.getReader();
|
|
let readUint8Array = new Uint8Array();
|
|
|
|
reader.read().then(function processText({ done, value }) {
|
|
if (done) {
|
|
expect(readUint8Array).toEqual(inputUint8Array);
|
|
testDone.resolve(); // Correctly signal that the test is done.
|
|
return;
|
|
}
|
|
readUint8Array = new Uint8Array([...readUint8Array, ...value]);
|
|
return reader.read().then(processText);
|
|
});
|
|
|
|
return testDone.promise; // Return the promise to properly wait for the test to complete.
|
|
});
|
|
|
|
|
|
tap.test('should handle transform with a write function', async (toolsArg) => {
|
|
const testDone = toolsArg.defer();
|
|
const input = [1, 2, 3, 4, 5];
|
|
const expectedOutput = [2, 4, 6, 8, 10];
|
|
|
|
const transformStream = new webstream.WebDuplexStream<number, number>({
|
|
writeFunction: (chunk, { push }) => {
|
|
push(chunk * 2); // Push the doubled number into the stream
|
|
return Promise.resolve(); // Resolve the promise immediately
|
|
},
|
|
});
|
|
|
|
const writableStream = transformStream.writable.getWriter();
|
|
const readableStream = transformStream.readable.getReader();
|
|
|
|
const output: number[] = [];
|
|
|
|
// Process the text and resolve the test once done.
|
|
const processText = async ({ done, value }) => {
|
|
if (done) {
|
|
expect(output).toEqual(expectedOutput);
|
|
testDone.resolve(); // Resolve the deferred test once all values have been read.
|
|
return;
|
|
}
|
|
if (value !== undefined) {
|
|
output.push(value);
|
|
}
|
|
// Continue reading and processing.
|
|
await readableStream.read().then(processText);
|
|
};
|
|
|
|
// Start the read process before writing to the stream.
|
|
readableStream.read().then(processText);
|
|
|
|
// Sequentially write to the stream and close when done.
|
|
for (const num of input) {
|
|
await writableStream.write(num);
|
|
}
|
|
await writableStream.close();
|
|
|
|
return testDone.promise; // This will wait until the testDone is resolved before completing the test.
|
|
});
|
|
|
|
|
|
tap.start();
|