@cloudpss/ubjson 0.5.11 → 0.5.13

package/tests/stream/many.js

@@ -0,0 +1,100 @@
+import { Readable } from 'node:stream';
+import { encodeMany, decodeMany } from '../../dist/stream/index.js';
+import { buffer } from 'node:stream/consumers';
+import { finished } from 'node:stream/promises';
+
+/**
+ * iterableToAsyncIterable
+ * @template T
+ * @param {Iterable<T>} iterable - iterable
+ * @returns {AsyncIterable<T>} async iterable
+ */
+function iterableToAsyncIterable(iterable) {
+    return {
+        [Symbol.asyncIterator]: () => {
+            const iterator = iterable[Symbol.iterator]();
+            return {
+                next: () => Promise.resolve(iterator.next()),
+            };
+        },
+    };
+}
+
+/**
+ * asyncIterableToArray
+ * @template T
+ * @param {AsyncIterable<T>} asyncIterable - async iterable
+ * @returns {Promise<Array<T>>} array
+ */
+async function asyncIterableToArray(asyncIterable) {
+    const array = [];
+    for await (const item of asyncIterable) {
+        array.push(item);
+    }
+    return array;
+}
+
+test('encode/decode many', async () => {
+    const data = [
+        {
+            a: 1,
+            b: 2,
+            c: 3,
+            d: 4,
+            e: 5,
+        },
+        1,
+        null,
+        'x',
+        true,
+        [1, 2, 3],
+        Uint8Array.of(3, 3, 1),
+    ];
+    const encoded = await buffer(encodeMany(iterableToAsyncIterable(data)));
+    const decoded = await asyncIterableToArray(decodeMany(Readable.from([encoded])));
+    expect(decoded).toEqual([
+        {
+            a: 1,
+            b: 2,
+            c: 3,
+            d: 4,
+            e: 5,
+        },
+        1,
+        // null is not allowed in stream
+        'x',
+        true,
+        [1, 2, 3],
+        Uint8Array.of(3, 3, 1),
+    ]);
+});
+
+test('encode/decode many with invalid value', async () => {
+    await expect(async () => await finished(encodeMany(iterableToAsyncIterable([1, () => 1])))).rejects.toThrow();
+});
+
+test('encode/decode many with error', async () => {
+    await expect(
+        async () =>
+            await finished(
+                encodeMany(
+                    (async function* () {
+                        yield 1;
+                        await Promise.resolve();
+                        throw new Error('xx');
+                    })(),
+                ),
+            ),
+    ).rejects.toThrow('xx');
+});
+
+test('encode/decode many with undefined', async () => {
+    const data = [1, null, undefined, [undefined]];
+    const encoded = await buffer(encodeMany(iterableToAsyncIterable(data)));
+    const decoded = await asyncIterableToArray(decodeMany(Readable.from([encoded])));
+    expect(decoded).toEqual([
+        1,
+        // null is not allowed in stream
+        [null],
+    ]);
+});