@eggjs/supertest 9.0.0-beta.18 → 9.0.0-beta.20

package/dist/index.d.ts

@@ -1,17 +1,172 @@
-import { AgentOptions, App } from "./types.js";
-import { AssertFunction, CallbackFunction, ExpectHeader, ResponseError, Test, TestApplication } from "./test.js";
-import { Request, RequestOptions } from "./request.js";
-import { TestAgent, proxyAgent } from "./agent.js";
+import { RequestListener } from "node:http";
+import { Http2ServerRequest, Http2ServerResponse } from "node:http2";
+import { AgentOptions, Request as Request$1, Response, agent } from "superagent";
+import { Server } from "node:net";
 
+//#region src/types.d.ts
+type H2RequestListener = (request: Http2ServerRequest, response: Http2ServerResponse) => void;
+type H1RequestListener = RequestListener;
+type App = Server | H1RequestListener | H2RequestListener | string;
+interface AgentOptions$1 extends AgentOptions {
+  http2?: boolean;
+}
+//#endregion
+//#region src/error/AssertError.d.ts
+declare class AssertError extends Error {
+  expected: any;
+  actual: any;
+  constructor(message: string, expected: any, actual: any, options?: ErrorOptions);
+}
+//#endregion
+//#region src/test.d.ts
+type TestApplication = Server | string;
+type AssertFunction = (res: Response) => AssertError | void;
+type CallbackFunction = (err: AssertError | Error | null, res: Response) => void;
+type ResponseError = Error & {
+  syscall?: string;
+  code?: string;
+  status?: number;
+};
+interface ExpectHeader {
+  name: string;
+  value: string | number | RegExp;
+}
+declare class Test extends Request$1 {
+  app: TestApplication;
+  _server: Server;
+  _asserts: AssertFunction[];
+  /**
+   * Initialize a new `Test` with the given `app`,
+   * request `method` and `path`.
+   */
+  constructor(app: TestApplication, method: string, path: string);
+  /**
+   * Returns a URL, extracted from a server.
+   *
+   * @return {String} URL address
+   * @private
+   */
+  protected serverAddress(app: Server, path: string): string;
+  /**
+   * Expectations:
+   *
+   * ```js
+   *   .expect(200)
+   *   .expect(200, fn)
+   *   .expect(200, body)
+   *   .expect('Some body')
+   *   .expect('Some body', fn)
+   *   .expect(['json array body', { key: 'val' }])
+   *   .expect('Content-Type', 'application/json')
+   *   .expect('Content-Type', 'application/json', fn)
+   *   .expect(fn)
+   *   .expect([200, 404])
+   * ```
+   *
+   * @return {Test} The current Test instance for chaining.
+   */
+  expect(a: number | string | RegExp | object | AssertFunction, b?: string | number | RegExp | CallbackFunction, c?: CallbackFunction): Test;
+  /**
+   * UnExpectations:
+   *
+   *   .unexpectHeader('Content-Type')
+   *   .unexpectHeader('Content-Type', fn)
+   */
+  unexpectHeader(name: string, fn?: CallbackFunction): this;
+  /**
+   * Expectations:
+   *
+   *   .expectHeader('Content-Type')
+   *   .expectHeader('Content-Type', fn)
+   */
+  expectHeader(name: string, fn?: CallbackFunction): this;
+  _unexpectHeader(name: string, res: Response): AssertError | undefined;
+  _expectHeader(name: string, res: Response): AssertError | undefined;
+  /**
+   * Defer invoking superagent's `.end()` until
+   * the server is listening.
+   */
+  end(fn: CallbackFunction): this;
+  /**
+   * Perform assertions and invoke `fn(err, res)`.
+   */
+  assert(resError: ResponseError | null, res: Response, fn: CallbackFunction): void;
+  /**
+   * Perform assertions on a response body and return an Error upon failure.
+   */
+  _assertBody(body: RegExp | string | number | object | null | undefined, res: Response): AssertError | undefined;
+  /**
+   * Perform assertions on a response header and return an Error upon failure.
+   */
+  _assertHeader(header: ExpectHeader, res: Response): AssertError | undefined;
+  /**
+   * Perform assertions on the response status and return an Error upon failure.
+   */
+  _assertStatus(status: number, res: Response): AssertError | undefined;
+  /**
+   * Perform assertions on the response status and return an Error upon failure.
+   */
+  _assertStatusArray(statusArray: number[], res: Response): AssertError | undefined;
+  /**
+   * Performs an assertion by calling a function and return an Error upon failure.
+   */
+  _assertFunction(fn: AssertFunction, res: Response): Error | undefined;
+}
+//#endregion
+//#region src/request.d.ts
+interface RequestOptions {
+  http2?: boolean;
+}
+declare class Request {
+  #private;
+  app: string | Server;
+  constructor(appOrListener: App, options?: RequestOptions);
+  protected _testRequest(method: string, url: string): Test;
+  delete(url: string): Test;
+  del(url: string): Test;
+  get(url: string): Test;
+  head(url: string): Test;
+  put(url: string): Test;
+  post(url: string): Test;
+  patch(url: string): Test;
+  options(url: string): Test;
+  trace(url: string): Test;
+}
+//#endregion
+//#region src/agent.d.ts
+/**
+ * Initialize a new `TestAgent`.
+ *
+ * @param {Function|Server} app
+ * @param {Object} options
+ */
+declare class TestAgent extends agent {
+  #private;
+  app: Server | string;
+  _host: string;
+  constructor(appOrListener: App, options?: AgentOptions$1);
+  host(host: string): this;
+  protected _testRequest(method: string, url: string): Test;
+  delete(url: string): Test;
+  del(url: string): Test;
+  get(url: string): Test;
+  head(url: string): Test;
+  put(url: string): Test;
+  post(url: string): Test;
+  patch(url: string): Test;
+  options(url: string): Test;
+  trace(url: string): Test;
+}
+declare const proxyAgent: typeof TestAgent;
+//#endregion
 //#region src/index.d.ts
-
 /**
  * Test against the given `app`,
  * returning a new `Test`.
  */
 declare function request(app: App, options?: RequestOptions): Request;
 declare const _default: ((app: App, options?: RequestOptions) => Request) & {
-  agent: (app: App, options?: AgentOptions) => TestAgent;
+  agent: (app: App, options?: AgentOptions$1) => TestAgent;
 };
 //#endregion
 export { AssertFunction, CallbackFunction, ExpectHeader, Request, type RequestOptions, ResponseError, Test, TestAgent, TestApplication, proxyAgent as agent, _default as default, request };

package/dist/index.js

@@ -1,7 +1,367 @@
-import { Test } from "./test.js";
-import { Request } from "./request.js";
-import { TestAgent, proxyAgent } from "./agent.js";
+import http, { STATUS_CODES } from "node:http";
+import http2 from "node:http2";
+import { inspect } from "node:util";
+import { Server } from "node:tls";
+import { deepStrictEqual } from "node:assert";
+import { Request as Request$1, agent } from "superagent";
 
+//#region src/error/AssertError.ts
+var AssertError = class extends Error {
+	expected;
+	actual;
+	constructor(message, expected, actual, options) {
+		super(message, options);
+		this.name = this.constructor.name;
+		this.expected = expected;
+		this.actual = actual;
+		Error.captureStackTrace(this, this.constructor);
+	}
+};
+
+//#endregion
+//#region src/test.ts
+var Test = class extends Request$1 {
+	app;
+	_server;
+	_asserts = [];
+	/**
+	* Initialize a new `Test` with the given `app`,
+	* request `method` and `path`.
+	*/
+	constructor(app, method, path) {
+		super(method.toUpperCase(), path);
+		this.redirects(0);
+		this.buffer();
+		this.app = app;
+		this.url = typeof app === "string" ? app + path : this.serverAddress(app, path);
+	}
+	/**
+	* Returns a URL, extracted from a server.
+	*
+	* @return {String} URL address
+	* @private
+	*/
+	serverAddress(app, path) {
+		if (!app.address()) this._server = app.listen(0);
+		const port = app.address().port;
+		return `${app instanceof Server || this._server instanceof Server ? "https" : "http"}://127.0.0.1:${port}${path}`;
+	}
+	/**
+	* Expectations:
+	*
+	* ```js
+	*   .expect(200)
+	*   .expect(200, fn)
+	*   .expect(200, body)
+	*   .expect('Some body')
+	*   .expect('Some body', fn)
+	*   .expect(['json array body', { key: 'val' }])
+	*   .expect('Content-Type', 'application/json')
+	*   .expect('Content-Type', 'application/json', fn)
+	*   .expect(fn)
+	*   .expect([200, 404])
+	* ```
+	*
+	* @return {Test} The current Test instance for chaining.
+	*/
+	expect(a, b, c) {
+		if (typeof a === "function") {
+			this._asserts.push(wrapAssertFn(a));
+			return this;
+		}
+		if (typeof b === "function") this.end(b);
+		if (typeof c === "function") this.end(c);
+		if (typeof a === "number") {
+			this._asserts.push(wrapAssertFn(this._assertStatus.bind(this, a)));
+			if (typeof b !== "function" && arguments.length > 1) this._asserts.push(wrapAssertFn(this._assertBody.bind(this, b)));
+			return this;
+		}
+		if (Array.isArray(a) && a.length > 0 && a.every((val) => typeof val === "number")) {
+			this._asserts.push(wrapAssertFn(this._assertStatusArray.bind(this, a)));
+			return this;
+		}
+		if (typeof b === "string" || typeof b === "number" || b instanceof RegExp) {
+			this._asserts.push(wrapAssertFn(this._assertHeader.bind(this, {
+				name: String(a),
+				value: b
+			})));
+			return this;
+		}
+		this._asserts.push(wrapAssertFn(this._assertBody.bind(this, a)));
+		return this;
+	}
+	/**
+	* UnExpectations:
+	*
+	*   .unexpectHeader('Content-Type')
+	*   .unexpectHeader('Content-Type', fn)
+	*/
+	unexpectHeader(name, fn) {
+		if (typeof fn === "function") this.end(fn);
+		if (typeof name === "string") this._asserts.push(this._unexpectHeader.bind(this, name));
+		return this;
+	}
+	/**
+	* Expectations:
+	*
+	*   .expectHeader('Content-Type')
+	*   .expectHeader('Content-Type', fn)
+	*/
+	expectHeader(name, fn) {
+		if (typeof fn === "function") this.end(fn);
+		if (typeof name === "string") this._asserts.push(this._expectHeader.bind(this, name));
+		return this;
+	}
+	_unexpectHeader(name, res) {
+		const actual = res.headers[name.toLowerCase()];
+		if (actual) return new AssertError("unexpected \"" + name + "\" header field, got \"" + actual + "\"", name, actual);
+	}
+	_expectHeader(name, res) {
+		const actual = res.headers[name.toLowerCase()];
+		if (!actual) return new AssertError("expected \"" + name + "\" header field", name, actual);
+	}
+	/**
+	* Defer invoking superagent's `.end()` until
+	* the server is listening.
+	*/
+	end(fn) {
+		const server = this._server;
+		super.end((err, res) => {
+			const localAssert = () => {
+				this.assert(err, res, fn);
+			};
+			if (server && "_handle" in server && server._handle) return server.close(localAssert);
+			localAssert();
+		});
+		return this;
+	}
+	/**
+	* Perform assertions and invoke `fn(err, res)`.
+	*/
+	assert(resError, res, fn) {
+		let errorObj;
+		const sysErrors = {
+			ECONNREFUSED: "Connection refused",
+			ECONNRESET: "Connection reset by peer",
+			EPIPE: "Broken pipe",
+			ETIMEDOUT: "Operation timed out"
+		};
+		if (!res && resError) if (resError instanceof Error && resError.syscall === "connect" && resError.code && sysErrors[resError.code]) errorObj = /* @__PURE__ */ new Error(resError.code + ": " + sysErrors[resError.code]);
+		else errorObj = resError;
+		for (let i = 0; i < this._asserts.length && !errorObj; i += 1) errorObj = this._assertFunction(this._asserts[i], res);
+		if (!errorObj && resError instanceof Error && (!res || resError.status !== res.status)) errorObj = resError;
+		if (!fn) {
+			console.warn("[@eggjs/supertest] no callback function provided, fn: %s", typeof fn);
+			return;
+		}
+		fn.call(this, errorObj || null, res);
+	}
+	/**
+	* Perform assertions on a response body and return an Error upon failure.
+	*/
+	_assertBody(body, res) {
+		const isRegexp = body instanceof RegExp;
+		if (typeof body === "object" && !isRegexp) try {
+			deepStrictEqual(body, res.body);
+		} catch (err) {
+			const a = inspect(body);
+			const b = inspect(res.body);
+			return new AssertError("expected " + a + " response body, got " + b, body, res.body, { cause: err });
+		}
+		else if (body !== res.text) {
+			const a = inspect(body);
+			const b = inspect(res.text);
+			if (isRegexp) {
+				if (!body.test(res.text)) return new AssertError("expected body " + b + " to match " + body, body, res.body);
+			} else return new AssertError("expected " + a + " response body, got " + b, body, res.body);
+		}
+	}
+	/**
+	* Perform assertions on a response header and return an Error upon failure.
+	*/
+	_assertHeader(header, res) {
+		const field = header.name;
+		const actual = res.header[field.toLowerCase()];
+		const fieldExpected = header.value;
+		if (typeof actual === "undefined") return new AssertError("expected \"" + field + "\" header field", header, actual);
+		if (Array.isArray(actual) && actual.toString() === fieldExpected || fieldExpected === actual) return;
+		if (fieldExpected instanceof RegExp) {
+			if (!fieldExpected.test(actual)) return new AssertError("expected \"" + field + "\" matching " + fieldExpected + ", got \"" + actual + "\"", header, actual);
+		} else return new AssertError("expected \"" + field + "\" of \"" + fieldExpected + "\", got \"" + actual + "\"", header, actual);
+	}
+	/**
+	* Perform assertions on the response status and return an Error upon failure.
+	*/
+	_assertStatus(status, res) {
+		if (res.status !== status) {
+			const a = STATUS_CODES[status];
+			const b = STATUS_CODES[res.status];
+			return new AssertError("expected " + status + " \"" + a + "\", got " + res.status + " \"" + b + "\"", status, res.status);
+		}
+	}
+	/**
+	* Perform assertions on the response status and return an Error upon failure.
+	*/
+	_assertStatusArray(statusArray, res) {
+		if (!statusArray.includes(res.status)) {
+			const b = STATUS_CODES[res.status];
+			const expectedList = statusArray.join(", ");
+			return new AssertError("expected one of \"" + expectedList + "\", got " + res.status + " \"" + b + "\"", statusArray, res.status);
+		}
+	}
+	/**
+	* Performs an assertion by calling a function and return an Error upon failure.
+	*/
+	_assertFunction(fn, res) {
+		let err;
+		try {
+			err = fn(res);
+		} catch (e) {
+			err = e;
+		}
+		if (err instanceof Error) return err;
+	}
+};
+/**
+* Wraps an assert function into another.
+* The wrapper function edit the stack trace of any assertion error, prepending a more useful stack to it.
+*
+* @param {Function} assertFn
+* @return {Function} wrapped assert function
+*/
+function wrapAssertFn(assertFn) {
+	const savedStack = (/* @__PURE__ */ new Error()).stack.split("\n").slice(3);
+	return (res) => {
+		let badStack;
+		let err;
+		try {
+			err = assertFn(res);
+		} catch (e) {
+			err = e;
+		}
+		if (err instanceof Error && err.stack) {
+			badStack = err.stack.replace(err.message, "").split("\n").slice(1);
+			err.stack = [err.toString()].concat(savedStack).concat("----").concat(badStack).join("\n");
+		}
+		return err;
+	};
+}
+
+//#endregion
+//#region src/request.ts
+var Request = class {
+	app;
+	#http2 = false;
+	constructor(appOrListener, options = {}) {
+		if (typeof appOrListener === "function") if (options.http2) {
+			this.#http2 = true;
+			this.app = http2.createServer(appOrListener);
+		} else this.app = http.createServer(appOrListener);
+		else this.app = appOrListener;
+	}
+	_testRequest(method, url) {
+		const req = new Test(this.app, method.toUpperCase(), url);
+		if (this.#http2) req.http2();
+		return req;
+	}
+	delete(url) {
+		return this._testRequest("delete", url);
+	}
+	del(url) {
+		return this._testRequest("delete", url);
+	}
+	get(url) {
+		return this._testRequest("get", url);
+	}
+	head(url) {
+		return this._testRequest("head", url);
+	}
+	put(url) {
+		return this._testRequest("put", url);
+	}
+	post(url) {
+		return this._testRequest("post", url);
+	}
+	patch(url) {
+		return this._testRequest("patch", url);
+	}
+	options(url) {
+		return this._testRequest("options", url);
+	}
+	trace(url) {
+		return this._testRequest("trace", url);
+	}
+};
+
+//#endregion
+//#region src/agent.ts
+/**
+* Initialize a new `TestAgent`.
+*
+* @param {Function|Server} app
+* @param {Object} options
+*/
+var TestAgent = class extends agent {
+	app;
+	_host;
+	#http2 = false;
+	constructor(appOrListener, options = {}) {
+		super(options);
+		if (typeof appOrListener === "function") if (options.http2) {
+			this.#http2 = true;
+			this.app = http2.createServer(appOrListener);
+		} else this.app = http.createServer(appOrListener);
+		else this.app = appOrListener;
+	}
+	host(host) {
+		this._host = host;
+		return this;
+	}
+	_testRequest(method, url) {
+		const req = new Test(this.app, method.toUpperCase(), url);
+		if (this.#http2) req.http2();
+		if (this._host) req.set("host", this._host);
+		const that = this;
+		req.on("response", that._saveCookies.bind(this));
+		req.on("redirect", that._saveCookies.bind(this));
+		req.on("redirect", that._attachCookies.bind(this, req));
+		that._setDefaults(req);
+		that._attachCookies(req);
+		return req;
+	}
+	delete(url) {
+		return this._testRequest("delete", url);
+	}
+	del(url) {
+		return this._testRequest("delete", url);
+	}
+	get(url) {
+		return this._testRequest("get", url);
+	}
+	head(url) {
+		return this._testRequest("head", url);
+	}
+	put(url) {
+		return this._testRequest("put", url);
+	}
+	post(url) {
+		return this._testRequest("post", url);
+	}
+	patch(url) {
+		return this._testRequest("patch", url);
+	}
+	options(url) {
+		return this._testRequest("options", url);
+	}
+	trace(url) {
+		return this._testRequest("trace", url);
+	}
+};
+const proxyAgent = new Proxy(TestAgent, { apply(target, _, argumentsList) {
+	return new target(argumentsList[0], argumentsList[1]);
+} });
+
+//#endregion
 //#region src/index.ts
 /**
 * Test against the given `app`,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@eggjs/supertest",
   "description": "SuperAgent driven library for testing HTTP servers",
-  "version": "9.0.0-beta.18",
+  "version": "9.0.0-beta.20",
   "publishConfig": {
     "access": "public"
   },
@@ -48,7 +48,7 @@
     "cookie-parser": "^1.4.6",
     "express": "^4.21.2",
     "tsdown": "^0.15.4",
-    "typescript": "5.9.2"
+    "typescript": "^5.9.3"
   },
   "scripts": {
     "build": "tsdown",

package/dist/agent.d.ts

@@ -1,33 +0,0 @@
-import { AgentOptions as AgentOptions$1, App } from "./types.js";
-import { Test } from "./test.js";
-import { agent } from "superagent";
-import { Server } from "node:net";
-
-//#region src/agent.d.ts
-
-/**
- * Initialize a new `TestAgent`.
- *
- * @param {Function|Server} app
- * @param {Object} options
- */
-declare class TestAgent extends agent {
-  #private;
-  app: Server | string;
-  _host: string;
-  constructor(appOrListener: App, options?: AgentOptions$1);
-  host(host: string): this;
-  protected _testRequest(method: string, url: string): Test;
-  delete(url: string): Test;
-  del(url: string): Test;
-  get(url: string): Test;
-  head(url: string): Test;
-  put(url: string): Test;
-  post(url: string): Test;
-  patch(url: string): Test;
-  options(url: string): Test;
-  trace(url: string): Test;
-}
-declare const proxyAgent: typeof TestAgent;
-//#endregion
-export { TestAgent, proxyAgent };

package/dist/agent.js

@@ -1,74 +0,0 @@
-import { Test } from "./test.js";
-import http from "node:http";
-import http2 from "node:http2";
-import { agent } from "superagent";
-
-//#region src/agent.ts
-/**
-* Initialize a new `TestAgent`.
-*
-* @param {Function|Server} app
-* @param {Object} options
-*/
-var TestAgent = class extends agent {
-	app;
-	_host;
-	#http2 = false;
-	constructor(appOrListener, options = {}) {
-		super(options);
-		if (typeof appOrListener === "function") if (options.http2) {
-			this.#http2 = true;
-			this.app = http2.createServer(appOrListener);
-		} else this.app = http.createServer(appOrListener);
-		else this.app = appOrListener;
-	}
-	host(host) {
-		this._host = host;
-		return this;
-	}
-	_testRequest(method, url) {
-		const req = new Test(this.app, method.toUpperCase(), url);
-		if (this.#http2) req.http2();
-		if (this._host) req.set("host", this._host);
-		const that = this;
-		req.on("response", that._saveCookies.bind(this));
-		req.on("redirect", that._saveCookies.bind(this));
-		req.on("redirect", that._attachCookies.bind(this, req));
-		that._setDefaults(req);
-		that._attachCookies(req);
-		return req;
-	}
-	delete(url) {
-		return this._testRequest("delete", url);
-	}
-	del(url) {
-		return this._testRequest("delete", url);
-	}
-	get(url) {
-		return this._testRequest("get", url);
-	}
-	head(url) {
-		return this._testRequest("head", url);
-	}
-	put(url) {
-		return this._testRequest("put", url);
-	}
-	post(url) {
-		return this._testRequest("post", url);
-	}
-	patch(url) {
-		return this._testRequest("patch", url);
-	}
-	options(url) {
-		return this._testRequest("options", url);
-	}
-	trace(url) {
-		return this._testRequest("trace", url);
-	}
-};
-const proxyAgent = new Proxy(TestAgent, { apply(target, _, argumentsList) {
-	return new target(argumentsList[0], argumentsList[1]);
-} });
-
-//#endregion
-export { TestAgent, proxyAgent };

package/dist/error/AssertError.d.ts

@@ -1,8 +0,0 @@
-//#region src/error/AssertError.d.ts
-declare class AssertError extends Error {
-  expected: any;
-  actual: any;
-  constructor(message: string, expected: any, actual: any, options?: ErrorOptions);
-}
-//#endregion
-export { AssertError };

package/dist/error/AssertError.js

@@ -1,15 +0,0 @@
-//#region src/error/AssertError.ts
-var AssertError = class extends Error {
-	expected;
-	actual;
-	constructor(message, expected, actual, options) {
-		super(message, options);
-		this.name = this.constructor.name;
-		this.expected = expected;
-		this.actual = actual;
-		Error.captureStackTrace(this, this.constructor);
-	}
-};
-
-//#endregion
-export { AssertError };

package/dist/request.d.ts

@@ -1,25 +0,0 @@
-import { App } from "./types.js";
-import { Test } from "./test.js";
-import { Server } from "node:net";
-
-//#region src/request.d.ts
-interface RequestOptions {
-  http2?: boolean;
-}
-declare class Request {
-  #private;
-  app: string | Server;
-  constructor(appOrListener: App, options?: RequestOptions);
-  protected _testRequest(method: string, url: string): Test;
-  delete(url: string): Test;
-  del(url: string): Test;
-  get(url: string): Test;
-  head(url: string): Test;
-  put(url: string): Test;
-  post(url: string): Test;
-  patch(url: string): Test;
-  options(url: string): Test;
-  trace(url: string): Test;
-}
-//#endregion
-export { Request, RequestOptions };

package/dist/request.js

@@ -1,51 +0,0 @@
-import { Test } from "./test.js";
-import http from "node:http";
-import http2 from "node:http2";
-
-//#region src/request.ts
-var Request = class {
-	app;
-	#http2 = false;
-	constructor(appOrListener, options = {}) {
-		if (typeof appOrListener === "function") if (options.http2) {
-			this.#http2 = true;
-			this.app = http2.createServer(appOrListener);
-		} else this.app = http.createServer(appOrListener);
-		else this.app = appOrListener;
-	}
-	_testRequest(method, url) {
-		const req = new Test(this.app, method.toUpperCase(), url);
-		if (this.#http2) req.http2();
-		return req;
-	}
-	delete(url) {
-		return this._testRequest("delete", url);
-	}
-	del(url) {
-		return this._testRequest("delete", url);
-	}
-	get(url) {
-		return this._testRequest("get", url);
-	}
-	head(url) {
-		return this._testRequest("head", url);
-	}
-	put(url) {
-		return this._testRequest("put", url);
-	}
-	post(url) {
-		return this._testRequest("post", url);
-	}
-	patch(url) {
-		return this._testRequest("patch", url);
-	}
-	options(url) {
-		return this._testRequest("options", url);
-	}
-	trace(url) {
-		return this._testRequest("trace", url);
-	}
-};
-
-//#endregion
-export { Request };

package/dist/test.d.ts

@@ -1,100 +0,0 @@
-import { AssertError } from "./error/AssertError.js";
-import { Request, Response } from "superagent";
-import { Server } from "node:net";
-
-//#region src/test.d.ts
-type TestApplication = Server | string;
-type AssertFunction = (res: Response) => AssertError | void;
-type CallbackFunction = (err: AssertError | Error | null, res: Response) => void;
-type ResponseError = Error & {
-  syscall?: string;
-  code?: string;
-  status?: number;
-};
-interface ExpectHeader {
-  name: string;
-  value: string | number | RegExp;
-}
-declare class Test extends Request {
-  app: TestApplication;
-  _server: Server;
-  _asserts: AssertFunction[];
-  /**
-   * Initialize a new `Test` with the given `app`,
-   * request `method` and `path`.
-   */
-  constructor(app: TestApplication, method: string, path: string);
-  /**
-   * Returns a URL, extracted from a server.
-   *
-   * @return {String} URL address
-   * @private
-   */
-  protected serverAddress(app: Server, path: string): string;
-  /**
-   * Expectations:
-   *
-   * ```js
-   *   .expect(200)
-   *   .expect(200, fn)
-   *   .expect(200, body)
-   *   .expect('Some body')
-   *   .expect('Some body', fn)
-   *   .expect(['json array body', { key: 'val' }])
-   *   .expect('Content-Type', 'application/json')
-   *   .expect('Content-Type', 'application/json', fn)
-   *   .expect(fn)
-   *   .expect([200, 404])
-   * ```
-   *
-   * @return {Test} The current Test instance for chaining.
-   */
-  expect(a: number | string | RegExp | object | AssertFunction, b?: string | number | RegExp | CallbackFunction, c?: CallbackFunction): Test;
-  /**
-   * UnExpectations:
-   *
-   *   .unexpectHeader('Content-Type')
-   *   .unexpectHeader('Content-Type', fn)
-   */
-  unexpectHeader(name: string, fn?: CallbackFunction): this;
-  /**
-   * Expectations:
-   *
-   *   .expectHeader('Content-Type')
-   *   .expectHeader('Content-Type', fn)
-   */
-  expectHeader(name: string, fn?: CallbackFunction): this;
-  _unexpectHeader(name: string, res: Response): AssertError | undefined;
-  _expectHeader(name: string, res: Response): AssertError | undefined;
-  /**
-   * Defer invoking superagent's `.end()` until
-   * the server is listening.
-   */
-  end(fn: CallbackFunction): this;
-  /**
-   * Perform assertions and invoke `fn(err, res)`.
-   */
-  assert(resError: ResponseError | null, res: Response, fn: CallbackFunction): void;
-  /**
-   * Perform assertions on a response body and return an Error upon failure.
-   */
-  _assertBody(body: RegExp | string | number | object | null | undefined, res: Response): AssertError | undefined;
-  /**
-   * Perform assertions on a response header and return an Error upon failure.
-   */
-  _assertHeader(header: ExpectHeader, res: Response): AssertError | undefined;
-  /**
-   * Perform assertions on the response status and return an Error upon failure.
-   */
-  _assertStatus(status: number, res: Response): AssertError | undefined;
-  /**
-   * Perform assertions on the response status and return an Error upon failure.
-   */
-  _assertStatusArray(statusArray: number[], res: Response): AssertError | undefined;
-  /**
-   * Performs an assertion by calling a function and return an Error upon failure.
-   */
-  _assertFunction(fn: AssertFunction, res: Response): Error | undefined;
-}
-//#endregion
-export { AssertFunction, CallbackFunction, ExpectHeader, ResponseError, Test, TestApplication };

package/dist/test.js

@@ -1,237 +0,0 @@
-import { AssertError } from "./error/AssertError.js";
-import { STATUS_CODES } from "node:http";
-import { inspect } from "node:util";
-import { Server } from "node:tls";
-import { deepStrictEqual } from "node:assert";
-import { Request } from "superagent";
-
-//#region src/test.ts
-var Test = class extends Request {
-	app;
-	_server;
-	_asserts = [];
-	/**
-	* Initialize a new `Test` with the given `app`,
-	* request `method` and `path`.
-	*/
-	constructor(app, method, path) {
-		super(method.toUpperCase(), path);
-		this.redirects(0);
-		this.buffer();
-		this.app = app;
-		this.url = typeof app === "string" ? app + path : this.serverAddress(app, path);
-	}
-	/**
-	* Returns a URL, extracted from a server.
-	*
-	* @return {String} URL address
-	* @private
-	*/
-	serverAddress(app, path) {
-		if (!app.address()) this._server = app.listen(0);
-		const port = app.address().port;
-		return `${app instanceof Server || this._server instanceof Server ? "https" : "http"}://127.0.0.1:${port}${path}`;
-	}
-	/**
-	* Expectations:
-	*
-	* ```js
-	*   .expect(200)
-	*   .expect(200, fn)
-	*   .expect(200, body)
-	*   .expect('Some body')
-	*   .expect('Some body', fn)
-	*   .expect(['json array body', { key: 'val' }])
-	*   .expect('Content-Type', 'application/json')
-	*   .expect('Content-Type', 'application/json', fn)
-	*   .expect(fn)
-	*   .expect([200, 404])
-	* ```
-	*
-	* @return {Test} The current Test instance for chaining.
-	*/
-	expect(a, b, c) {
-		if (typeof a === "function") {
-			this._asserts.push(wrapAssertFn(a));
-			return this;
-		}
-		if (typeof b === "function") this.end(b);
-		if (typeof c === "function") this.end(c);
-		if (typeof a === "number") {
-			this._asserts.push(wrapAssertFn(this._assertStatus.bind(this, a)));
-			if (typeof b !== "function" && arguments.length > 1) this._asserts.push(wrapAssertFn(this._assertBody.bind(this, b)));
-			return this;
-		}
-		if (Array.isArray(a) && a.length > 0 && a.every((val) => typeof val === "number")) {
-			this._asserts.push(wrapAssertFn(this._assertStatusArray.bind(this, a)));
-			return this;
-		}
-		if (typeof b === "string" || typeof b === "number" || b instanceof RegExp) {
-			this._asserts.push(wrapAssertFn(this._assertHeader.bind(this, {
-				name: String(a),
-				value: b
-			})));
-			return this;
-		}
-		this._asserts.push(wrapAssertFn(this._assertBody.bind(this, a)));
-		return this;
-	}
-	/**
-	* UnExpectations:
-	*
-	*   .unexpectHeader('Content-Type')
-	*   .unexpectHeader('Content-Type', fn)
-	*/
-	unexpectHeader(name, fn) {
-		if (typeof fn === "function") this.end(fn);
-		if (typeof name === "string") this._asserts.push(this._unexpectHeader.bind(this, name));
-		return this;
-	}
-	/**
-	* Expectations:
-	*
-	*   .expectHeader('Content-Type')
-	*   .expectHeader('Content-Type', fn)
-	*/
-	expectHeader(name, fn) {
-		if (typeof fn === "function") this.end(fn);
-		if (typeof name === "string") this._asserts.push(this._expectHeader.bind(this, name));
-		return this;
-	}
-	_unexpectHeader(name, res) {
-		const actual = res.headers[name.toLowerCase()];
-		if (actual) return new AssertError("unexpected \"" + name + "\" header field, got \"" + actual + "\"", name, actual);
-	}
-	_expectHeader(name, res) {
-		const actual = res.headers[name.toLowerCase()];
-		if (!actual) return new AssertError("expected \"" + name + "\" header field", name, actual);
-	}
-	/**
-	* Defer invoking superagent's `.end()` until
-	* the server is listening.
-	*/
-	end(fn) {
-		const server = this._server;
-		super.end((err, res) => {
-			const localAssert = () => {
-				this.assert(err, res, fn);
-			};
-			if (server && "_handle" in server && server._handle) return server.close(localAssert);
-			localAssert();
-		});
-		return this;
-	}
-	/**
-	* Perform assertions and invoke `fn(err, res)`.
-	*/
-	assert(resError, res, fn) {
-		let errorObj;
-		const sysErrors = {
-			ECONNREFUSED: "Connection refused",
-			ECONNRESET: "Connection reset by peer",
-			EPIPE: "Broken pipe",
-			ETIMEDOUT: "Operation timed out"
-		};
-		if (!res && resError) if (resError instanceof Error && resError.syscall === "connect" && resError.code && sysErrors[resError.code]) errorObj = /* @__PURE__ */ new Error(resError.code + ": " + sysErrors[resError.code]);
-		else errorObj = resError;
-		for (let i = 0; i < this._asserts.length && !errorObj; i += 1) errorObj = this._assertFunction(this._asserts[i], res);
-		if (!errorObj && resError instanceof Error && (!res || resError.status !== res.status)) errorObj = resError;
-		if (!fn) {
-			console.warn("[@eggjs/supertest] no callback function provided, fn: %s", typeof fn);
-			return;
-		}
-		fn.call(this, errorObj || null, res);
-	}
-	/**
-	* Perform assertions on a response body and return an Error upon failure.
-	*/
-	_assertBody(body, res) {
-		const isRegexp = body instanceof RegExp;
-		if (typeof body === "object" && !isRegexp) try {
-			deepStrictEqual(body, res.body);
-		} catch (err) {
-			const a = inspect(body);
-			const b = inspect(res.body);
-			return new AssertError("expected " + a + " response body, got " + b, body, res.body, { cause: err });
-		}
-		else if (body !== res.text) {
-			const a = inspect(body);
-			const b = inspect(res.text);
-			if (isRegexp) {
-				if (!body.test(res.text)) return new AssertError("expected body " + b + " to match " + body, body, res.body);
-			} else return new AssertError("expected " + a + " response body, got " + b, body, res.body);
-		}
-	}
-	/**
-	* Perform assertions on a response header and return an Error upon failure.
-	*/
-	_assertHeader(header, res) {
-		const field = header.name;
-		const actual = res.header[field.toLowerCase()];
-		const fieldExpected = header.value;
-		if (typeof actual === "undefined") return new AssertError("expected \"" + field + "\" header field", header, actual);
-		if (Array.isArray(actual) && actual.toString() === fieldExpected || fieldExpected === actual) return;
-		if (fieldExpected instanceof RegExp) {
-			if (!fieldExpected.test(actual)) return new AssertError("expected \"" + field + "\" matching " + fieldExpected + ", got \"" + actual + "\"", header, actual);
-		} else return new AssertError("expected \"" + field + "\" of \"" + fieldExpected + "\", got \"" + actual + "\"", header, actual);
-	}
-	/**
-	* Perform assertions on the response status and return an Error upon failure.
-	*/
-	_assertStatus(status, res) {
-		if (res.status !== status) {
-			const a = STATUS_CODES[status];
-			const b = STATUS_CODES[res.status];
-			return new AssertError("expected " + status + " \"" + a + "\", got " + res.status + " \"" + b + "\"", status, res.status);
-		}
-	}
-	/**
-	* Perform assertions on the response status and return an Error upon failure.
-	*/
-	_assertStatusArray(statusArray, res) {
-		if (!statusArray.includes(res.status)) {
-			const b = STATUS_CODES[res.status];
-			const expectedList = statusArray.join(", ");
-			return new AssertError("expected one of \"" + expectedList + "\", got " + res.status + " \"" + b + "\"", statusArray, res.status);
-		}
-	}
-	/**
-	* Performs an assertion by calling a function and return an Error upon failure.
-	*/
-	_assertFunction(fn, res) {
-		let err;
-		try {
-			err = fn(res);
-		} catch (e) {
-			err = e;
-		}
-		if (err instanceof Error) return err;
-	}
-};
-/**
-* Wraps an assert function into another.
-* The wrapper function edit the stack trace of any assertion error, prepending a more useful stack to it.
-*
-* @param {Function} assertFn
-* @return {Function} wrapped assert function
-*/
-function wrapAssertFn(assertFn) {
-	const savedStack = (/* @__PURE__ */ new Error()).stack.split("\n").slice(3);
-	return (res) => {
-		let badStack;
-		let err;
-		try {
-			err = assertFn(res);
-		} catch (e) {
-			err = e;
-		}
-		if (err instanceof Error && err.stack) {
-			badStack = err.stack.replace(err.message, "").split("\n").slice(1);
-			err.stack = [err.toString()].concat(savedStack).concat("----").concat(badStack).join("\n");
-		}
-		return err;
-	};
-}
-
-//#endregion
-export { Test };

package/dist/types.d.ts

@@ -1,14 +0,0 @@
-import { RequestListener } from "node:http";
-import { Http2ServerRequest, Http2ServerResponse } from "node:http2";
-import { AgentOptions } from "superagent";
-import { Server } from "node:net";
-
-//#region src/types.d.ts
-type H2RequestListener = (request: Http2ServerRequest, response: Http2ServerResponse) => void;
-type H1RequestListener = RequestListener;
-type App = Server | H1RequestListener | H2RequestListener | string;
-interface AgentOptions$1 extends AgentOptions {
-  http2?: boolean;
-}
-//#endregion
-export { AgentOptions$1 as AgentOptions, App };