@p0security/cli 0.19.8 → 0.19.10

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

@@ -1,688 +0,0 @@
-"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