fix(stream): let PushReadableStream handle cancelled streams.

Also add tests

Relates to #648

libraries/adb/src/commands/subprocess/protocols/none.spec.ts

@@ -0,0 +1,151 @@
+import { describe, expect, it, jest } from "@jest/globals";
+import { PromiseResolver } from "@yume-chan/async";
+import { ReadableStream, WritableStream } from "@yume-chan/stream-extra";
+
+import type { AdbSocket } from "../../../adb.js";
+
+import { AdbSubprocessNoneProtocol } from "./none.js";
+
+describe("AdbSubprocessNoneProtocol", () => {
+    describe("stdout", () => {
+        it("should pipe data from `socket`", async () => {
+            const closed = new PromiseResolver<void>();
+            const socket: AdbSocket = {
+                service: "",
+                close: jest.fn(() => {}),
+                closed: closed.promise,
+                readable: new ReadableStream({
+                    async start(controller) {
+                        controller.enqueue(new Uint8Array([1, 2, 3]));
+                        controller.enqueue(new Uint8Array([4, 5, 6]));
+                        await closed.promise;
+                        controller.close();
+                    },
+                }),
+                writable: new WritableStream(),
+            };
+
+            const process = new AdbSubprocessNoneProtocol(socket);
+            const reader = process.stdout.getReader();
+
+            await expect(reader.read()).resolves.toEqual({
+                done: false,
+                value: new Uint8Array([1, 2, 3]),
+            });
+            await expect(reader.read()).resolves.toEqual({
+                done: false,
+                value: new Uint8Array([4, 5, 6]),
+            });
+        });
+
+        it("should close when `socket` is closed", async () => {
+            const closed = new PromiseResolver<void>();
+            const socket: AdbSocket = {
+                service: "",
+                close: jest.fn(() => {}),
+                closed: closed.promise,
+                readable: new ReadableStream({
+                    async start(controller) {
+                        controller.enqueue(new Uint8Array([1, 2, 3]));
+                        controller.enqueue(new Uint8Array([4, 5, 6]));
+                        await closed.promise;
+                        controller.close();
+                    },
+                }),
+                writable: new WritableStream(),
+            };
+
+            const process = new AdbSubprocessNoneProtocol(socket);
+            const reader = process.stdout.getReader();
+
+            await expect(reader.read()).resolves.toEqual({
+                done: false,
+                value: new Uint8Array([1, 2, 3]),
+            });
+            await expect(reader.read()).resolves.toEqual({
+                done: false,
+                value: new Uint8Array([4, 5, 6]),
+            });
+
+            closed.resolve();
+
+            await expect(reader.read()).resolves.toEqual({
+                done: true,
+            });
+        });
+    });
+
+    describe("stderr", () => {
+        it("should be empty", async () => {
+            const closed = new PromiseResolver<void>();
+            const socket: AdbSocket = {
+                service: "",
+                close: jest.fn(() => {}),
+                closed: closed.promise,
+                readable: new ReadableStream({
+                    async start(controller) {
+                        controller.enqueue(new Uint8Array([1, 2, 3]));
+                        controller.enqueue(new Uint8Array([4, 5, 6]));
+                        await closed.promise;
+                        controller.close();
+                    },
+                }),
+                writable: new WritableStream(),
+            };
+
+            const process = new AdbSubprocessNoneProtocol(socket);
+            const reader = process.stderr.getReader();
+
+            closed.resolve();
+
+            await expect(reader.read()).resolves.toEqual({ done: true });
+        });
+    });
+
+    describe("exit", () => {
+        it("should resolve when `socket` closes", async () => {
+            const closed = new PromiseResolver<void>();
+            const socket: AdbSocket = {
+                service: "",
+                close: jest.fn(() => {}),
+                closed: closed.promise,
+                readable: new ReadableStream(),
+                writable: new WritableStream(),
+            };
+
+            const process = new AdbSubprocessNoneProtocol(socket);
+
+            closed.resolve();
+
+            await expect(process.exit).resolves.toBe(0);
+        });
+    });
+
+    it("`resize` shouldn't throw any error", () => {
+        const socket: AdbSocket = {
+            service: "",
+            close: jest.fn(() => {}),
+            closed: new PromiseResolver<void>().promise,
+            readable: new ReadableStream(),
+            writable: new WritableStream(),
+        };
+
+        const process = new AdbSubprocessNoneProtocol(socket);
+        expect(() => process.resize()).not.toThrow();
+    });
+
+    it("`kill` should close `socket`", async () => {
+        const close = jest.fn(() => {});
+        const socket: AdbSocket = {
+            service: "",
+            close,
+            closed: new PromiseResolver<void>().promise,
+            readable: new ReadableStream(),
+            writable: new WritableStream(),
+        };
+
+        const process = new AdbSubprocessNoneProtocol(socket);
+        await process.kill();
+        expect(close).toHaveBeenCalledTimes(1);
+    });
+});