@clickup/rest-client 2.10.296 → 2.11.1

package/docs/interfaces/RestOptions.md

@@ -126,6 +126,18 @@ addresses are allowed.
 
 ___
 
+### responseEncoding
+
+• **responseEncoding**: `undefined` \| `BufferEncoding`
+
+Overrides the default encoding heuristics for responses.
+
+#### Defined in
+
+[src/RestOptions.ts:100](https://github.com/clickup/rest-client/blob/master/src/RestOptions.ts#L100)
+
+___
+
 ### isDebug
 
 • **isDebug**: `boolean`
@@ -134,7 +146,7 @@ If true, logs request-response pairs to console.
 
 #### Defined in
 
-[src/RestOptions.ts:100](https://github.com/clickup/rest-client/blob/master/src/RestOptions.ts#L100)
+[src/RestOptions.ts:102](https://github.com/clickup/rest-client/blob/master/src/RestOptions.ts#L102)
 
 ___
 
@@ -153,7 +165,7 @@ Sets Keep-Alive parameters (persistent connections).
 
 #### Defined in
 
-[src/RestOptions.ts:104](https://github.com/clickup/rest-client/blob/master/src/RestOptions.ts#L104)
+[src/RestOptions.ts:106](https://github.com/clickup/rest-client/blob/master/src/RestOptions.ts#L106)
 
 ___
 
@@ -165,7 +177,7 @@ When resolving DNS, use IPv4, IPv6 or both (see dns.lookup() docs).
 
 #### Defined in
 
-[src/RestOptions.ts:112](https://github.com/clickup/rest-client/blob/master/src/RestOptions.ts#L112)
+[src/RestOptions.ts:114](https://github.com/clickup/rest-client/blob/master/src/RestOptions.ts#L114)
 
 ___
 
@@ -177,7 +189,7 @@ Max timeout to wait for a response.
 
 #### Defined in
 
-[src/RestOptions.ts:114](https://github.com/clickup/rest-client/blob/master/src/RestOptions.ts#L114)
+[src/RestOptions.ts:116](https://github.com/clickup/rest-client/blob/master/src/RestOptions.ts#L116)
 
 ___
 
@@ -192,9 +204,6 @@ delay events logging.
 
 ▸ (`event`): `void`
 
-Logger to be used for each responses (including retried) plus for backoff
-delay events logging.
-
 ##### Parameters
 
 | Name | Type |
@@ -207,7 +216,7 @@ delay events logging.
 
 #### Defined in
 
-[src/RestOptions.ts:117](https://github.com/clickup/rest-client/blob/master/src/RestOptions.ts#L117)
+[src/RestOptions.ts:119](https://github.com/clickup/rest-client/blob/master/src/RestOptions.ts#L119)
 
 ___
 
@@ -219,7 +228,7 @@ Middlewares to wrap requests. May alter both request and response.
 
 #### Defined in
 
-[src/RestOptions.ts:119](https://github.com/clickup/rest-client/blob/master/src/RestOptions.ts#L119)
+[src/RestOptions.ts:121](https://github.com/clickup/rest-client/blob/master/src/RestOptions.ts#L121)
 
 ___
 
@@ -244,19 +253,6 @@ remote API is that weird. Return values:
 
 ▸ (`res`): ``"SUCCESS"`` \| ``"THROW"`` \| ``"BEST_EFFORT"``
 
-If set, makes decision whether the response is successful or not. The
-response will either be returned to the client, or an error will be thrown.
-This allows to treat some non-successful HTTP statuses as success if the
-remote API is that weird. Return values:
-* "SUCCESS" - the request will be considered successful, no further checks
-  will be performed;
-* "BEST_EFFORT" - inconclusive, the request may be either successful or
-  unsuccessful, additional tests (e.g. will check HTTP status code) will be
-  performed;
-* "THROW" - the request resulted in error. Additional tests will be
-  performed to determine is the error is retriable, is OAuth token good,
-  and etc.
-
 ##### Parameters
 
 | Name | Type |
@@ -269,7 +265,7 @@ remote API is that weird. Return values:
 
 #### Defined in
 
-[src/RestOptions.ts:132](https://github.com/clickup/rest-client/blob/master/src/RestOptions.ts#L132)
+[src/RestOptions.ts:134](https://github.com/clickup/rest-client/blob/master/src/RestOptions.ts#L134)
 
 ___
 
@@ -291,16 +287,6 @@ contradictory information; then isRateLimitError wins.
 
 ▸ (`res`): `number` \| ``"BEST_EFFORT"`` \| ``"SOMETHING_ELSE"`` \| ``"RATE_LIMIT"``
 
-Decides whether the response is a rate-limit error or not. Returning
-non-zero value is treated as retry delay (if retries are set up). In case
-the returned value is "SOMETHING_ELSE", the response ought to be either
-success or some other error. Returning "BEST_EFFORT" turns on built-in
-heuristic (e.g. relying on HTTP status code and Retry-After header). In
-case we've made a decision that it's a rate limited error, the request is
-always retried; this covers a very common case when we have both
-isRateLimitError and isRetriableError handlers set up, and they return
-contradictory information; then isRateLimitError wins.
-
 ##### Parameters
 
 | Name | Type |
@@ -313,7 +299,7 @@ contradictory information; then isRateLimitError wins.
 
 #### Defined in
 
-[src/RestOptions.ts:142](https://github.com/clickup/rest-client/blob/master/src/RestOptions.ts#L142)
+[src/RestOptions.ts:144](https://github.com/clickup/rest-client/blob/master/src/RestOptions.ts#L144)
 
 ___
 
@@ -328,9 +314,6 @@ not, the response ought to be either success or some other error.
 
 ▸ (`res`): `boolean`
 
-Decides whether the response is a token-invalid error or not. In case it's
-not, the response ought to be either success or some other error.
-
 ##### Parameters
 
 | Name | Type |
@@ -343,7 +326,7 @@ not, the response ought to be either success or some other error.
 
 #### Defined in
 
-[src/RestOptions.ts:147](https://github.com/clickup/rest-client/blob/master/src/RestOptions.ts#L147)
+[src/RestOptions.ts:149](https://github.com/clickup/rest-client/blob/master/src/RestOptions.ts#L149)
 
 ___
 
@@ -363,14 +346,6 @@ retry will happen in not less than this number of milliseconds.
 
 ▸ (`res`, `_error`): `number` \| ``"BEST_EFFORT"`` \| ``"NEVER_RETRY"`` \| ``"RETRY"``
 
-Called only if we haven't decided earlier that it's a rate limit error.
-Decides whether the response is a retriable error or not. In case the
-returned value is "NEVER_RETRY", the response ought to be either success or
-some other error, but it's guaranteed that the request won't be retried.
-Returning "BEST_EFFORT" turns on built-in heuristics (e.g. never retry "not
-found" errors). Returning a number is treated as "RETRY", and the next
-retry will happen in not less than this number of milliseconds.
-
 ##### Parameters
 
 | Name | Type |
@@ -384,4 +359,4 @@ retry will happen in not less than this number of milliseconds.
 
 #### Defined in
 
-[src/RestOptions.ts:155](https://github.com/clickup/rest-client/blob/master/src/RestOptions.ts#L155)
+[src/RestOptions.ts:157](https://github.com/clickup/rest-client/blob/master/src/RestOptions.ts#L157)

package/docs/modules.md

@@ -15,8 +15,6 @@
 - [RestRetriableError](classes/RestRetriableError.md)
 - [RestTimeoutError](classes/RestTimeoutError.md)
 - [RestTokenInvalidError](classes/RestTokenInvalidError.md)
-- [PacerComposite](classes/PacerComposite.md)
-- [PacerQPS](classes/PacerQPS.md)
 
 ## Interfaces
 
@@ -24,10 +22,8 @@
 - [RestLogEvent](interfaces/RestLogEvent.md)
 - [Middleware](interfaces/Middleware.md)
 - [RestOptions](interfaces/RestOptions.md)
-- [PacerDelay](interfaces/PacerDelay.md)
 - [Pacer](interfaces/Pacer.md)
-- [PacerQPSBackend](interfaces/PacerQPSBackend.md)
-- [PacerQPSOptions](interfaces/PacerQPSOptions.md)
+- [PacerOutcome](interfaces/PacerOutcome.md)
 
 ## Functions
 
@@ -67,7 +63,7 @@ ___
 
 ### paceRequests
 
-▸ **paceRequests**(`pacer`): [`Middleware`](interfaces/Middleware.md)
+▸ **paceRequests**(`pacer`, `delayMetric?`): [`Middleware`](interfaces/Middleware.md)
 
 Rest Client middleware that adds some delay between requests using one of
 Pacer implementations.
@@ -77,6 +73,7 @@ Pacer implementations.
 | Name | Type |
 | :------ | :------ |
 | `pacer` | ``null`` \| [`Pacer`](interfaces/Pacer.md) \| (`req`: [`RestRequest`](classes/RestRequest.md)\<`any`\>) => `Promise`\<``null`` \| [`Pacer`](interfaces/Pacer.md)\> |
+| `delayMetric?` | (`delay`: `number`, `reason`: `string`) => `void` |
 
 #### Returns
 
@@ -84,4 +81,4 @@ Pacer implementations.
 
 #### Defined in
 
-[src/middlewares/paceRequests.ts:11](https://github.com/clickup/rest-client/blob/master/src/middlewares/paceRequests.ts#L11)
+[src/middlewares/paceRequests.ts:33](https://github.com/clickup/rest-client/blob/master/src/middlewares/paceRequests.ts#L33)

package/internal/clean.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+set -e
+
+rm -rf dist yarn.lock package-lock.json node_modules ./*.log

package/internal/deploy.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -e
+
+npm run build
+npm run lint
+npm run test
+npm publish --access=public

package/internal/docs.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+set -e
+
+rm -rf docs
+typedoc --plugin typedoc-plugin-markdown --plugin typedoc-plugin-merge-modules
+sed -i '' -E 's#packages/[^/]+/##g' $(find docs -type f -name '*.md')

package/internal/lint.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+set -e
+
+eslint . --ext .ts --cache --cache-location dist/.eslintcache

package/jest.config.base.js

@@ -0,0 +1,18 @@
+"use strict";
+module.exports = {
+  roots: ["<rootDir>/src"],
+  testMatch: ["**/*.test.ts"],
+  clearMocks: true,
+  restoreMocks: true,
+  ...(process.env.IN_JEST_PROJECT
+    ? {}
+    : { testTimeout: 30000 }),
+  transform: {
+    "\\.ts$": "ts-jest",
+    "\\.m?js$": "babel-jest",
+  },
+  transformIgnorePatterns: [
+    "<rootDir>/node_modules/.pnpm/(?!(cacheable-lookup)@)",
+    "node_modules/(?!.pnpm|cacheable-lookup)",
+  ],
+};

package/jest.config.js

@@ -1,11 +1,2 @@
 "use strict";
-module.exports = {
-  roots: ["<rootDir>/src"],
-  testMatch: ["**/*.test.ts"],
-  clearMocks: true,
-  restoreMocks: true,
-  ...(process.env.IN_JEST_PROJECT ? {} : { forceExit: true }),
-  transform: {
-    "\\.ts$": "ts-jest",
-  },
-};
+module.exports = { ...require("./jest.config.base") };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@clickup/rest-client",
   "description": "A syntax sugar tool around Node fetch() API, tailored to work with TypeScript and response validators",
-  "version": "2.10.296",
+  "version": "2.11.1",
   "license": "MIT",
   "keywords": [
     "rest-client",
@@ -24,47 +24,52 @@
   "scripts": {
     "build": "tsc",
     "dev": "tsc --watch --preserveWatchOutput",
-    "lint": "eslint . --ext .ts --cache --cache-location dist/.eslintcache",
+    "lint": "bash internal/lint.sh",
     "test": "jest",
-    "docs": "rm -rf docs && typedoc --plugin typedoc-plugin-markdown --plugin typedoc-plugin-merge-modules && sed -i '' -E 's#packages/[^/]+/##g' $(find docs -type f -name '*.md')",
-    "clean": "rm -rf dist node_modules yarn.lock package-lock.json pnpm-lock.yaml *.log",
+    "docs": "bash internal/docs.sh",
+    "clean": "bash internal/clean.sh",
     "copy-package-to-public-dir": "copy-package-to-public-dir.sh",
     "backport-package-from-public-dir": "backport-package-from-public-dir.sh",
-    "deploy": "npm run build && npm run lint && npm run test && npm publish --access=public"
+    "deploy": "bash internal/deploy.sh"
   },
   "dependencies": {
     "abort-controller": "^3.0.0",
+    "cacheable-lookup": "^7.0.0",
     "delay": "^4.4.1",
-    "fast-typescript-memoize": "^1.0.2",
+    "fast-typescript-memoize": "^1.1.1",
     "ipaddr.js": "^1.9.1",
     "lodash": "^4.17.21",
     "node-fetch": "^2.6.11",
     "oauth-1.0a": "^2.2.6"
   },
   "devDependencies": {
+    "@babel/core": "^7.29.0",
+    "@babel/preset-env": "^7.29.0",
     "@types/jest": "^29.5.5",
     "@types/lodash": "^4.14.175",
-    "@types/node-fetch": "^2.6.4",
     "@types/node": "^20.4.1",
+    "@types/node-fetch": "^2.6.4",
     "@typescript-eslint/eslint-plugin": "^5.59.6",
     "@typescript-eslint/parser": "^5.59.6",
+    "babel-jest": "^29.7.0",
+    "eslint": "^8.40.0",
     "eslint-import-resolver-typescript": "^3.5.5",
     "eslint-plugin-import": "^2.27.5",
     "eslint-plugin-lodash": "^7.4.0",
+    "eslint-plugin-no-only-tests": "^3.1.0",
     "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-react-hooks": "^4.6.0",
     "eslint-plugin-react": "^7.32.2",
+    "eslint-plugin-react-hooks": "^4.6.0",
     "eslint-plugin-typescript-enum": "^2.1.0",
     "eslint-plugin-typescript-sort-keys": "^2.3.0",
     "eslint-plugin-unused-imports": "^2.0.0",
-    "eslint": "^8.40.0",
     "jest": "^29.7.0",
     "prettier": "3.2.1",
     "superstruct": "^1.0.3",
     "ts-jest": "^29.1.1",
+    "typedoc": "^0.25.2",
     "typedoc-plugin-markdown": "^3.16.0",
     "typedoc-plugin-merge-modules": "^5.1.0",
-    "typedoc": "^0.25.2",
     "typescript": "^5.2.2"
   },
   "repository": {

package/src/RestClient.ts

@@ -480,8 +480,8 @@ function simpleShape(path: string, args?: any) {
     args && typeof args === "object"
       ? Object.keys(args)
           // Filter out args that are already mentioned in the path, e.g.
-          // /pages/:pageID/blocks.
-          .filter((arg) => !argsInPath.includes(arg))
+          // /pages/:pageID/blocks. Also filter out undefined args.
+          .filter((arg) => !argsInPath.includes(arg) && args[arg] !== undefined)
           .sort()
           .join(",")
       : "";

package/src/RestOptions.ts

@@ -96,6 +96,8 @@ export default interface RestOptions {
   /** If true, non-public IP addresses are allowed too; otherwise, only unicast
    * addresses are allowed. */
   allowInternalIPs: boolean;
+  /** Overrides the default encoding heuristics for responses. */
+  responseEncoding: NodeJS.BufferEncoding | undefined;
   /** If true, logs request-response pairs to console. */
   isDebug: boolean;
   /** @ignore Holds HttpsAgent/HttpAgent instances; used internally only. */
@@ -172,6 +174,7 @@ export const DEFAULT_OPTIONS: RestOptions = {
   throwIfResIsBigger: undefined,
   privateDataInResponse: false,
   allowInternalIPs: false,
+  responseEncoding: undefined,
   isDebug: false,
   agents: new Agents(),
   keepAlive: { timeoutMs: 10000 },

package/src/RestRequest.ts

@@ -1,5 +1,3 @@
-import dns from "dns";
-import { promisify } from "util";
 import { Memoize } from "fast-typescript-memoize";
 import { parse } from "ipaddr.js";
 import random from "lodash/random";
@@ -20,6 +18,36 @@ import RestStream from "./RestStream";
 
 const MAX_DEBUG_LEN = 1024 * 100;
 
+interface CacheableLookupEntry {
+  address: string;
+  family: 4 | 6;
+}
+
+interface CacheableLookupLike {
+  lookupAsync(hostname: string): Promise<CacheableLookupEntry>;
+  lookupAsync(
+    hostname: string,
+    options: { family: 4 | 6 },
+  ): Promise<CacheableLookupEntry>;
+}
+
+// cacheable-lookup v7 is ESM-only, while this library currently builds/tests in
+// a CommonJS flow. A cached dynamic import keeps both TypeScript node16 build
+// and runtime compatibility, and shares one lookup cache instance per process.
+const cacheableLookupPromise: Promise<CacheableLookupLike> = import(
+  "cacheable-lookup"
+).then(({ default: CacheableLookupClass }) => new CacheableLookupClass());
+
+const lookupHostname = async (
+  hostname: string,
+  family: RestOptions["family"],
+) => {
+  const cacheableLookup = await cacheableLookupPromise;
+  return family === 0
+    ? cacheableLookup.lookupAsync(hostname)
+    : cacheableLookup.lookupAsync(hostname, { family });
+};
+
 /**
  * Type TAssertShape allows to limit json()'s assert callbacks to only those
  * which return an object compatible with TAssertShape.
@@ -269,9 +297,7 @@ export default class RestRequest<TAssertShape = any> {
     // it in the URL; the hostname will be passed separately via Host header.
     const hostname = url.hostname;
     const headers = new Headers(this.headers);
-    const addr = await promisify(dns.lookup)(hostname, {
-      family: this.options.family,
-    });
+    const addr = await lookupHostname(hostname, this.options.family);
     let redirectMode: RequestRedirect = "follow";
     if (!this.options.allowInternalIPs) {
       const range = parse(addr.address).range();
@@ -347,6 +373,7 @@ export default class RestRequest<TAssertShape = any> {
           );
         }
       },
+      responseEncoding: this.options.responseEncoding,
     });
   }
 

package/src/__tests__/RestClient.test.ts

@@ -0,0 +1,53 @@
+import { RestClient } from "..";
+import substituteParams from "../internal/substituteParams";
+
+test("fetch_plain_url", async () => {
+  const client = new RestClient();
+  const res = await client.get("http://example.com", undefined, "*/*").text();
+  expect(res.length).toBeGreaterThan(10);
+});
+
+test("fetch_loopback_url_fails", async () => {
+  const client = new RestClient();
+  await expect(client.get("http://localhost/abc").response()).rejects.toThrow(
+    new RegExp(
+      "^Domain localhost resolves to a non-public \\(loopback\\) IP address (127\\.0\\.0\\.1)|(\\:\\:1)",
+    ),
+  );
+});
+
+test("fetch_private_url_fails", async () => {
+  const client = new RestClient();
+  await expect(client.get("http://10.0.0.1/abc").response()).rejects.toThrow(
+    "Domain 10.0.0.1 resolves to a non-public (private) IP address 10.0.0.1",
+  );
+});
+
+test("fetch_url_with_redirect_fails", async () => {
+  const client = new RestClient();
+  await expect(client.get("http://google.com").response()).rejects.toThrow(
+    /redirect mode is set to error:/,
+  );
+});
+
+test("fetch_relative_url_fails", async () => {
+  const client = new RestClient();
+  await expect(client.get("/test").text()).rejects.toThrow(/Invalid URL/);
+  await expect(client.get("zzz").text()).rejects.toThrow(/Invalid URL/);
+});
+
+test("substituteParams", async () => {
+  const body = { aa: "aaa", b: 42, x: "y" };
+  expect(substituteParams("/some/:aa/other/:b/ccc/:ddd/eee", body)).toEqual([
+    "/some/aaa/other/42/ccc/:ddd/eee",
+    { x: "y" },
+  ]);
+  expect(body).toEqual({ aa: "aaa", b: 42, x: "y" });
+});
+
+test("withOptions ignores undefined", async () => {
+  const request = new RestClient({ timeoutMs: 1234 })
+    .withOptions({ timeoutMs: undefined })
+    .writeJson("/", "");
+  expect(request.options.timeoutMs).toEqual(1234);
+});

package/src/__tests__/RestFetchReader.test.ts

@@ -0,0 +1,154 @@
+import delay from "delay";
+import range from "lodash/range";
+import {
+  BINARY_BUF,
+  consumeIterable,
+  createFetchReader,
+  server,
+  serverAssertConnectionsCount,
+  TimeoutError,
+  UTF8_BUF,
+} from "./helpers";
+
+let ORIGIN: string;
+
+beforeAll(async () => {
+  ORIGIN = await new Promise((resolve) => {
+    server.listen(0, () =>
+      resolve("http://127.0.0.1:" + (server.address() as any).port),
+    );
+  });
+});
+
+afterAll(async () => {
+  await new Promise((resolve) => server.close(resolve));
+});
+
+beforeEach(async () => {
+  await serverAssertConnectionsCount(0);
+});
+
+test("small_response", async () => {
+  const reader = createFetchReader(`${ORIGIN}/small`);
+  await reader.preload(1024);
+
+  expect(reader.textFetched).toEqual("ok");
+  expect(reader.textIsPartial).toBeFalsy();
+  expect(reader.charsRead).toEqual(reader.textFetched.length);
+
+  for await (const _ of reader) {
+    throw "Must not return any more data";
+  }
+
+  await serverAssertConnectionsCount(0);
+});
+
+test("large_response", async () => {
+  const reader = createFetchReader(`${ORIGIN}/large`);
+  await reader.preload(42);
+  await serverAssertConnectionsCount(1);
+
+  expect(reader.textFetched.length).toBeGreaterThan(1);
+  expect(reader.textFetched.length).toBeLessThan(1024 * 10);
+  expect(reader.textIsPartial).toBeTruthy();
+  expect(reader.charsRead).toEqual(reader.textFetched.length);
+
+  const rest = await consumeIterable(reader);
+  await serverAssertConnectionsCount(0);
+  expect(rest.length).toBeGreaterThan(1);
+  expect(reader.textIsPartial).toBeTruthy();
+  expect(reader.charsRead).toEqual(reader.textFetched.length + rest.length);
+});
+
+test("slow_response", async () => {
+  const reader = createFetchReader(`${ORIGIN}/slow`);
+  await reader.preload(42);
+  await delay(300);
+  await serverAssertConnectionsCount(1);
+  await reader[Symbol.asyncIterator]().return();
+  await serverAssertConnectionsCount(0);
+});
+
+test("small_slow_utf8_response", async () => {
+  const reader = createFetchReader(`${ORIGIN}/small_slow_utf8`);
+  await reader.preload(1);
+  await serverAssertConnectionsCount(1);
+  expect(reader.textFetched.length).toEqual(1);
+  expect(reader.charsRead).toEqual(1);
+  const rest = await consumeIterable(reader);
+  expect(reader.textFetched + rest).toEqual(UTF8_BUF.toString());
+  await serverAssertConnectionsCount(0);
+});
+
+test("too_big_response", async () => {
+  const reader = createFetchReader(`${ORIGIN}/large`, {
+    onAfterRead: (reader) => {
+      if (reader.charsRead > 1024 * 64) {
+        throw Error("too large");
+      }
+    },
+  });
+  await reader.preload(42);
+  await serverAssertConnectionsCount(1);
+  await expect(async () => consumeIterable(reader, 10)).rejects.toThrow(
+    "too large",
+  );
+  await serverAssertConnectionsCount(0);
+});
+
+test("timeout_response_no_preload_long_read_delay", async () => {
+  const reader = createFetchReader(`${ORIGIN}/slow`, { timeoutMs: 200 });
+  await expect(async () => consumeIterable(reader, 500)).rejects.toThrow(
+    TimeoutError,
+  );
+  await serverAssertConnectionsCount(0);
+});
+
+test("timeout_response_no_preload_short_read_delay", async () => {
+  const reader = createFetchReader(`${ORIGIN}/slow`, { timeoutMs: 200 });
+  await expect(async () => consumeIterable(reader, 10)).rejects.toThrow(
+    TimeoutError,
+  );
+  await serverAssertConnectionsCount(0);
+});
+
+test("timeout_in_preload", async () => {
+  const reader = createFetchReader(`${ORIGIN}/slow`, { timeoutMs: 200 });
+  await expect(async () => reader.preload(10000000)).rejects.toThrow(
+    TimeoutError,
+  );
+  await serverAssertConnectionsCount(0);
+});
+
+test("timeout_in_stream_after_preload_succeeded", async () => {
+  const reader = createFetchReader(`${ORIGIN}/slow`, { timeoutMs: 200 });
+  await reader.preload(42);
+  await serverAssertConnectionsCount(1);
+  await expect(async () => consumeIterable(reader, 10)).rejects.toThrow(
+    TimeoutError,
+  );
+  await serverAssertConnectionsCount(0);
+});
+
+test("timeout_after_reader_waited_for_too_long", async () => {
+  const reader = createFetchReader(`${ORIGIN}/slow`, { timeoutMs: 200 });
+  await reader.preload(42);
+  await serverAssertConnectionsCount(1);
+  await delay(500);
+  await expect(async () => consumeIterable(reader, 10)).rejects.toThrow(
+    TimeoutError,
+  );
+  await serverAssertConnectionsCount(0);
+});
+
+test("read_binary_data", async () => {
+  const reader = createFetchReader(`${ORIGIN}/binary`, { timeoutMs: 2000 });
+  await reader.preload(42);
+  const preload = reader.textFetched;
+  expect(reader.textIsPartial).toBeTruthy();
+  const data = await consumeIterable(reader, 10);
+  expect(Buffer.from(preload + data, "binary")).toEqual(
+    Buffer.concat(range(10).map(() => BINARY_BUF)),
+  );
+  await serverAssertConnectionsCount(0);
+});