@p0security/cli 0.18.9 → 0.18.11

package/build/dist/drivers/__tests__/api.test.js

@@ -0,0 +1,688 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const api_1 = require("../api");
+// Mock dependencies
+jest.mock("../config");
+jest.mock("../env");
+jest.mock("../../version", () => ({
+    p0VersionInfo: { version: "1.0.0" },
+}));
+describe("fetchWithStreaming", () => {
+    const mockAuthn = {
+        getToken: jest.fn().mockResolvedValue("mock-token"),
+        identity: {
+            org: { slug: "test-org" },
+        },
+    };
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    afterEach(() => {
+        // Clear all mocks after each test
+        jest.clearAllMocks();
+        jest.restoreAllMocks();
+    });
+    const createMockStreamingResponse = (chunks) => {
+        const encoder = new TextEncoder();
+        let chunkIndex = 0;
+        const mockReader = {
+            read: jest.fn().mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () {
+                if (chunkIndex < chunks.length) {
+                    const chunk = chunks[chunkIndex++];
+                    return {
+                        done: false,
+                        value: encoder.encode(chunk),
+                    };
+                }
+                return { done: true, value: undefined };
+            })),
+        };
+        return {
+            body: {
+                getReader: jest.fn().mockReturnValue(mockReader),
+            },
+        };
+    };
+    it("should yield data from streaming response", () => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, e_1, _b, _c;
+        const mockFetch = jest.spyOn(global, "fetch").mockResolvedValue(createMockStreamingResponse([
+            JSON.stringify({
+                type: "data",
+                data: { id: "1", message: "First chunk" },
+            }) + "\n",
+            JSON.stringify({
+                type: "data",
+                data: { id: "2", message: "Second chunk" },
+            }) + "\n",
+        ]));
+        const generator = (0, api_1.fetchWithStreaming)(mockAuthn, {
+            url: "/command",
+            method: "POST",
+            body: JSON.stringify({ test: "data" }),
+        });
+        const results = [];
+        try {
+            for (var _d = true, generator_1 = __asyncValues(generator), generator_1_1; generator_1_1 = yield generator_1.next(), _a = generator_1_1.done, !_a;) {
+                _c = generator_1_1.value;
+                _d = false;
+                try {
+                    const chunk = _c;
+                    results.push(chunk);
+                }
+                finally {
+                    _d = true;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = generator_1.return)) yield _b.call(generator_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        expect(results).toEqual([
+            { id: "1", message: "First chunk" },
+            { id: "2", message: "Second chunk" },
+        ]);
+        expect(mockFetch).toHaveBeenCalledWith("/command", {
+            method: "POST",
+            headers: {
+                authorization: "Bearer mock-token",
+                "Content-Type": "application/json",
+                "User-Agent": "P0 CLI/1.0.0",
+            },
+            body: JSON.stringify({ test: "data" }),
+            keepalive: true,
+        });
+    }));
+    it("should skip heartbeat messages", () => __awaiter(void 0, void 0, void 0, function* () {
+        var _e, e_2, _f, _g;
+        const chunks = [
+            JSON.stringify({
+                type: "heartbeat",
+            }) + "\n",
+            JSON.stringify({
+                type: "data",
+                data: { id: "1", message: "Real data" },
+            }) + "\n",
+            JSON.stringify({
+                type: "heartbeat",
+            }) + "\n",
+        ];
+        jest
+            .spyOn(global, "fetch")
+            .mockResolvedValue(createMockStreamingResponse(chunks));
+        const generator = (0, api_1.fetchWithStreaming)(mockAuthn, {
+            url: "/stream",
+            method: "GET",
+        });
+        const results = [];
+        try {
+            for (var _h = true, generator_2 = __asyncValues(generator), generator_2_1; generator_2_1 = yield generator_2.next(), _e = generator_2_1.done, !_e;) {
+                _g = generator_2_1.value;
+                _h = false;
+                try {
+                    const chunk = _g;
+                    results.push(chunk);
+                }
+                finally {
+                    _h = true;
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (!_h && !_e && (_f = generator_2.return)) yield _f.call(generator_2);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        expect(results).toEqual([{ id: "1", message: "Real data" }]);
+    }));
+    it("should throw error when response type is error", () => __awaiter(void 0, void 0, void 0, function* () {
+        const chunks = [
+            JSON.stringify({
+                type: "error",
+                error: "Something went wrong",
+            }) + "\n",
+        ];
+        jest
+            .spyOn(global, "fetch")
+            .mockResolvedValue(createMockStreamingResponse(chunks));
+        const generator = (0, api_1.fetchWithStreaming)(mockAuthn, {
+            url: "/stream",
+            method: "GET",
+        });
+        yield expect(() => __awaiter(void 0, void 0, void 0, function* () {
+            var _j, e_3, _k, _l;
+            try {
+                for (var _m = true, generator_3 = __asyncValues(generator), generator_3_1; generator_3_1 = yield generator_3.next(), _j = generator_3_1.done, !_j;) {
+                    _l = generator_3_1.value;
+                    _m = false;
+                    try {
+                        const _chunk = _l;
+                    }
+                    finally {
+                        _m = true;
+                    }
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (!_m && !_j && (_k = generator_3.return)) yield _k.call(generator_3);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+        })).rejects.toBe("Something went wrong");
+    }));
+    it("should throw error when data contains error", () => __awaiter(void 0, void 0, void 0, function* () {
+        const chunks = [
+            JSON.stringify({
+                type: "data",
+                data: { error: "Data error occurred" },
+            }) + "\n",
+        ];
+        jest
+            .spyOn(global, "fetch")
+            .mockResolvedValue(createMockStreamingResponse(chunks));
+        const generator = (0, api_1.fetchWithStreaming)(mockAuthn, {
+            url: "/stream",
+            method: "GET",
+        });
+        yield expect(() => __awaiter(void 0, void 0, void 0, function* () {
+            var _o, e_4, _p, _q;
+            try {
+                for (var _r = true, generator_4 = __asyncValues(generator), generator_4_1; generator_4_1 = yield generator_4.next(), _o = generator_4_1.done, !_o;) {
+                    _q = generator_4_1.value;
+                    _r = false;
+                    try {
+                        const _chunk = _q;
+                    }
+                    finally {
+                        _r = true;
+                    }
+                }
+            }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (!_r && !_o && (_p = generator_4.return)) yield _p.call(generator_4);
+                }
+                finally { if (e_4) throw e_4.error; }
+            }
+        })).rejects.toBe("Data error occurred");
+    }));
+    it("should throw error for invalid response format", () => __awaiter(void 0, void 0, void 0, function* () {
+        const chunks = [
+            JSON.stringify({
+                type: "unknown",
+                someData: "invalid",
+            }) + "\n",
+        ];
+        jest
+            .spyOn(global, "fetch")
+            .mockResolvedValue(createMockStreamingResponse(chunks));
+        const generator = (0, api_1.fetchWithStreaming)(mockAuthn, {
+            url: "/stream",
+            method: "GET",
+        });
+        yield expect(() => __awaiter(void 0, void 0, void 0, function* () {
+            var _s, e_5, _t, _u;
+            try {
+                for (var _v = true, generator_5 = __asyncValues(generator), generator_5_1; generator_5_1 = yield generator_5.next(), _s = generator_5_1.done, !_s;) {
+                    _u = generator_5_1.value;
+                    _v = false;
+                    try {
+                        const _chunk = _u;
+                    }
+                    finally {
+                        _v = true;
+                    }
+                }
+            }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+            finally {
+                try {
+                    if (!_v && !_s && (_t = generator_5.return)) yield _t.call(generator_5);
+                }
+                finally { if (e_5) throw e_5.error; }
+            }
+        })).rejects.toBe("Invalid response from the server");
+    }));
+    it("should handle multiple JSON objects in single chunk", () => __awaiter(void 0, void 0, void 0, function* () {
+        var _w, e_6, _x, _y;
+        const chunks = [
+            JSON.stringify({ type: "data", data: { id: "1\ntest" } }) +
+                "\n" +
+                JSON.stringify({ type: "data", data: { id: "2" } }) +
+                "\n",
+        ];
+        jest
+            .spyOn(global, "fetch")
+            .mockResolvedValue(createMockStreamingResponse(chunks));
+        const generator = (0, api_1.fetchWithStreaming)(mockAuthn, {
+            url: "/stream",
+            method: "GET",
+        });
+        const results = [];
+        try {
+            for (var _z = true, generator_6 = __asyncValues(generator), generator_6_1; generator_6_1 = yield generator_6.next(), _w = generator_6_1.done, !_w;) {
+                _y = generator_6_1.value;
+                _z = false;
+                try {
+                    const chunk = _y;
+                    results.push(chunk);
+                }
+                finally {
+                    _z = true;
+                }
+            }
+        }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        finally {
+            try {
+                if (!_z && !_w && (_x = generator_6.return)) yield _x.call(generator_6);
+            }
+            finally { if (e_6) throw e_6.error; }
+        }
+        expect(results).toEqual([{ id: "1\ntest" }, { id: "2" }]);
+    }));
+    it("should handle chunks with partial data", () => __awaiter(void 0, void 0, void 0, function* () {
+        var _0, e_7, _1, _2;
+        const chunks = [
+            '{"type":"data","data":{"id":"1"}}\n{"type":"heartbeat"}\n{"type":"da',
+            'ta","data":{"id":"2"}}\n', // Completes the JSON
+        ];
+        jest
+            .spyOn(global, "fetch")
+            .mockResolvedValue(createMockStreamingResponse(chunks));
+        const generator = (0, api_1.fetchWithStreaming)(mockAuthn, {
+            url: "/stream",
+            method: "GET",
+        });
+        const results = [];
+        try {
+            for (var _3 = true, generator_7 = __asyncValues(generator), generator_7_1; generator_7_1 = yield generator_7.next(), _0 = generator_7_1.done, !_0;) {
+                _2 = generator_7_1.value;
+                _3 = false;
+                try {
+                    const chunk = _2;
+                    results.push(chunk);
+                }
+                finally {
+                    _3 = true;
+                }
+            }
+        }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        finally {
+            try {
+                if (!_3 && !_0 && (_1 = generator_7.return)) yield _1.call(generator_7);
+            }
+            finally { if (e_7) throw e_7.error; }
+        }
+        expect(results).toEqual([{ id: "1" }, { id: "2" }]);
+    }));
+    it("should handle incomplete JSON across multiple chunks", () => __awaiter(void 0, void 0, void 0, function* () {
+        var _4, e_8, _5, _6;
+        // Simulate arbitrary chunks that split JSON objects
+        const chunks = [
+            '{"type":"data","data":{"id":"1","mess',
+            'age":"First chunk"}}\n{"type":"data",',
+            '"data":{"id":"2","message":"Second chu',
+            'nk"}}\n', // Completes second JSON
+        ];
+        jest
+            .spyOn(global, "fetch")
+            .mockResolvedValue(createMockStreamingResponse(chunks));
+        const generator = (0, api_1.fetchWithStreaming)(mockAuthn, {
+            url: "/stream",
+            method: "GET",
+        });
+        const results = [];
+        try {
+            for (var _7 = true, generator_8 = __asyncValues(generator), generator_8_1; generator_8_1 = yield generator_8.next(), _4 = generator_8_1.done, !_4;) {
+                _6 = generator_8_1.value;
+                _7 = false;
+                try {
+                    const chunk = _6;
+                    results.push(chunk);
+                }
+                finally {
+                    _7 = true;
+                }
+            }
+        }
+        catch (e_8_1) { e_8 = { error: e_8_1 }; }
+        finally {
+            try {
+                if (!_7 && !_4 && (_5 = generator_8.return)) yield _5.call(generator_8);
+            }
+            finally { if (e_8) throw e_8.error; }
+        }
+        expect(results).toEqual([
+            { id: "1", message: "First chunk" },
+            { id: "2", message: "Second chunk" },
+        ]);
+    }));
+    it("should handle single character chunks", () => __awaiter(void 0, void 0, void 0, function* () {
+        var _8, e_9, _9, _10;
+        // Each character as a separate chunk
+        const jsonString = '{"type":"data","data":{"id":"test"}}\n';
+        const chunks = jsonString.split("");
+        jest
+            .spyOn(global, "fetch")
+            .mockResolvedValue(createMockStreamingResponse(chunks));
+        const generator = (0, api_1.fetchWithStreaming)(mockAuthn, {
+            url: "/stream",
+            method: "GET",
+        });
+        const results = [];
+        try {
+            for (var _11 = true, generator_9 = __asyncValues(generator), generator_9_1; generator_9_1 = yield generator_9.next(), _8 = generator_9_1.done, !_8;) {
+                _10 = generator_9_1.value;
+                _11 = false;
+                try {
+                    const chunk = _10;
+                    results.push(chunk);
+                }
+                finally {
+                    _11 = true;
+                }
+            }
+        }
+        catch (e_9_1) { e_9 = { error: e_9_1 }; }
+        finally {
+            try {
+                if (!_11 && !_8 && (_9 = generator_9.return)) yield _9.call(generator_9);
+            }
+            finally { if (e_9) throw e_9.error; }
+        }
+        expect(results).toEqual([{ id: "test" }]);
+    }));
+    it("should handle chunks with no invalid json and no new lines", () => __awaiter(void 0, void 0, void 0, function* () {
+        const chunks = [
+            '{"type":"data","data":{"id":"1"}', // No newlines
+        ];
+        jest
+            .spyOn(global, "fetch")
+            .mockResolvedValue(createMockStreamingResponse(chunks));
+        const generator = (0, api_1.fetchWithStreaming)(mockAuthn, {
+            url: "/stream",
+            method: "GET",
+        });
+        yield expect(() => __awaiter(void 0, void 0, void 0, function* () {
+            var _12, e_10, _13, _14;
+            try {
+                for (var _15 = true, generator_10 = __asyncValues(generator), generator_10_1; generator_10_1 = yield generator_10.next(), _12 = generator_10_1.done, !_12;) {
+                    _14 = generator_10_1.value;
+                    _15 = false;
+                    try {
+                        const _chunk = _14;
+                    }
+                    finally {
+                        _15 = true;
+                    }
+                }
+            }
+            catch (e_10_1) { e_10 = { error: e_10_1 }; }
+            finally {
+                try {
+                    if (!_15 && !_12 && (_13 = generator_10.return)) yield _13.call(generator_10);
+                }
+                finally { if (e_10) throw e_10.error; }
+            }
+        })).rejects.toBe("Invalid response from the server");
+    }));
+    it("should handle empty chunks", () => __awaiter(void 0, void 0, void 0, function* () {
+        var _16, e_11, _17, _18;
+        const chunks = [
+            "",
+            '{"type":"data","data":{"id":"1"}}\n',
+            "",
+            '{"type":"data","data":{"id":"2"}}\n',
+        ];
+        jest
+            .spyOn(global, "fetch")
+            .mockResolvedValue(createMockStreamingResponse(chunks));
+        const generator = (0, api_1.fetchWithStreaming)(mockAuthn, {
+            url: "/stream",
+            method: "GET",
+        });
+        const results = [];
+        try {
+            for (var _19 = true, generator_11 = __asyncValues(generator), generator_11_1; generator_11_1 = yield generator_11.next(), _16 = generator_11_1.done, !_16;) {
+                _18 = generator_11_1.value;
+                _19 = false;
+                try {
+                    const chunk = _18;
+                    results.push(chunk);
+                }
+                finally {
+                    _19 = true;
+                }
+            }
+        }
+        catch (e_11_1) { e_11 = { error: e_11_1 }; }
+        finally {
+            try {
+                if (!_19 && !_16 && (_17 = generator_11.return)) yield _17.call(generator_11);
+            }
+            finally { if (e_11) throw e_11.error; }
+        }
+        expect(results).toEqual([{ id: "1" }, { id: "2" }]);
+    }));
+    it("should throw errors if there is leftover error chunk without new-line and a type", () => __awaiter(void 0, void 0, void 0, function* () {
+        const chunks = ['{"error":"Something went wrong"}'];
+        jest
+            .spyOn(global, "fetch")
+            .mockResolvedValue(createMockStreamingResponse(chunks));
+        const generator = (0, api_1.fetchWithStreaming)(mockAuthn, {
+            url: "/stream",
+            method: "GET",
+        });
+        yield expect(() => __awaiter(void 0, void 0, void 0, function* () {
+            var _20, e_12, _21, _22;
+            try {
+                for (var _23 = true, generator_12 = __asyncValues(generator), generator_12_1; generator_12_1 = yield generator_12.next(), _20 = generator_12_1.done, !_20;) {
+                    _22 = generator_12_1.value;
+                    _23 = false;
+                    try {
+                        const _chunk = _22;
+                    }
+                    finally {
+                        _23 = true;
+                    }
+                }
+            }
+            catch (e_12_1) { e_12 = { error: e_12_1 }; }
+            finally {
+                try {
+                    if (!_23 && !_20 && (_21 = generator_12.return)) yield _21.call(generator_12);
+                }
+                finally { if (e_12) throw e_12.error; }
+            }
+        })).rejects.toBe("Something went wrong");
+    }));
+    it("should throw network error for terminated", () => __awaiter(void 0, void 0, void 0, function* () {
+        jest.spyOn(global, "fetch").mockRejectedValue(new TypeError("terminated"));
+        const generator = (0, api_1.fetchWithStreaming)(mockAuthn, {
+            url: "/stream",
+            method: "GET",
+        });
+        yield expect(() => __awaiter(void 0, void 0, void 0, function* () {
+            var _24, e_13, _25, _26;
+            try {
+                for (var _27 = true, generator_13 = __asyncValues(generator), generator_13_1; generator_13_1 = yield generator_13.next(), _24 = generator_13_1.done, !_24;) {
+                    _26 = generator_13_1.value;
+                    _27 = false;
+                    try {
+                        const _chunk = _26;
+                    }
+                    finally {
+                        _27 = true;
+                    }
+                }
+            }
+            catch (e_13_1) { e_13 = { error: e_13_1 }; }
+            finally {
+                try {
+                    if (!_27 && !_24 && (_25 = generator_13.return)) yield _25.call(generator_13);
+                }
+                finally { if (e_13) throw e_13.error; }
+            }
+        })).rejects.toBe("Network error: Unable to reach the server.");
+    }));
+    it("should rethrow other errors", () => __awaiter(void 0, void 0, void 0, function* () {
+        const customError = new Error("Custom error");
+        jest.spyOn(global, "fetch").mockRejectedValue(customError);
+        const generator = (0, api_1.fetchWithStreaming)(mockAuthn, {
+            url: "/stream",
+            method: "GET",
+        });
+        yield expect(() => __awaiter(void 0, void 0, void 0, function* () {
+            var _28, e_14, _29, _30;
+            try {
+                for (var _31 = true, generator_14 = __asyncValues(generator), generator_14_1; generator_14_1 = yield generator_14.next(), _28 = generator_14_1.done, !_28;) {
+                    _30 = generator_14_1.value;
+                    _31 = false;
+                    try {
+                        const _chunk = _30;
+                    }
+                    finally {
+                        _31 = true;
+                    }
+                }
+            }
+            catch (e_14_1) { e_14 = { error: e_14_1 }; }
+            finally {
+                try {
+                    if (!_31 && !_28 && (_29 = generator_14.return)) yield _29.call(generator_14);
+                }
+                finally { if (e_14) throw e_14.error; }
+            }
+        })).rejects.toBe(customError);
+    }));
+    it("should throw network error for fetch failed", () => __awaiter(void 0, void 0, void 0, function* () {
+        jest
+            .spyOn(global, "fetch")
+            .mockRejectedValue(new TypeError("fetch failed"));
+        const generator = (0, api_1.fetchWithStreaming)(mockAuthn, {
+            url: "/stream",
+            method: "GET",
+        });
+        yield expect(() => __awaiter(void 0, void 0, void 0, function* () {
+            var _32, e_15, _33, _34;
+            try {
+                for (var _35 = true, generator_15 = __asyncValues(generator), generator_15_1; generator_15_1 = yield generator_15.next(), _32 = generator_15_1.done, !_32;) {
+                    _34 = generator_15_1.value;
+                    _35 = false;
+                    try {
+                        const _chunk = _34;
+                    }
+                    finally {
+                        _35 = true;
+                    }
+                }
+            }
+            catch (e_15_1) { e_15 = { error: e_15_1 }; }
+            finally {
+                try {
+                    if (!_35 && !_32 && (_33 = generator_15.return)) yield _33.call(generator_15);
+                }
+                finally { if (e_15) throw e_15.error; }
+            }
+        })).rejects.toBe("Network error: Unable to reach the server.");
+    }));
+    it("should throw error when no reader available", () => __awaiter(void 0, void 0, void 0, function* () {
+        jest.spyOn(global, "fetch").mockResolvedValue({
+            body: null,
+        });
+        const generator = (0, api_1.fetchWithStreaming)(mockAuthn, {
+            url: "/stream",
+            method: "GET",
+        });
+        yield expect(() => __awaiter(void 0, void 0, void 0, function* () {
+            var _36, e_16, _37, _38;
+            try {
+                for (var _39 = true, generator_16 = __asyncValues(generator), generator_16_1; generator_16_1 = yield generator_16.next(), _36 = generator_16_1.done, !_36;) {
+                    _38 = generator_16_1.value;
+                    _39 = false;
+                    try {
+                        const _chunk = _38;
+                    }
+                    finally {
+                        _39 = true;
+                    }
+                }
+            }
+            catch (e_16_1) { e_16 = { error: e_16_1 }; }
+            finally {
+                try {
+                    if (!_39 && !_36 && (_37 = generator_16.return)) yield _37.call(generator_16);
+                }
+                finally { if (e_16) throw e_16.error; }
+            }
+        })).rejects.toBe("No reader available");
+    }));
+    it("should use timeout when maxTimeoutMs is provided", () => __awaiter(void 0, void 0, void 0, function* () {
+        var _40, e_17, _41, _42;
+        const chunks = [
+            JSON.stringify({
+                type: "data",
+                data: { message: "success" },
+            }) + "\n",
+        ];
+        const mockFetch = jest
+            .spyOn(global, "fetch")
+            .mockResolvedValue(createMockStreamingResponse(chunks));
+        const generator = (0, api_1.fetchWithStreaming)(mockAuthn, {
+            url: "/stream",
+            method: "POST",
+            maxTimeoutMs: 5000,
+        });
+        const results = [];
+        try {
+            for (var _43 = true, generator_17 = __asyncValues(generator), generator_17_1; generator_17_1 = yield generator_17.next(), _40 = generator_17_1.done, !_40;) {
+                _42 = generator_17_1.value;
+                _43 = false;
+                try {
+                    const chunk = _42;
+                    results.push(chunk);
+                }
+                finally {
+                    _43 = true;
+                }
+            }
+        }
+        catch (e_17_1) { e_17 = { error: e_17_1 }; }
+        finally {
+            try {
+                if (!_43 && !_40 && (_41 = generator_17.return)) yield _41.call(generator_17);
+            }
+            finally { if (e_17) throw e_17.error; }
+        }
+        expect(mockFetch).toHaveBeenCalledWith("/stream", expect.objectContaining({
+            signal: expect.any(AbortSignal),
+        }));
+    }));
+});
+//# sourceMappingURL=api.test.js.map