@eggjs/supertest 8.0.0

package/LICENSE

@@ -0,0 +1,23 @@
+(The MIT License)
+
+Copyright (c) 2014 TJ Holowaychuk <tj@vision-media.ca>
+Copyright (c) 2024-present eggjs and the contributors.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,347 @@
+# @eggjs/supertest
+
+[![NPM version][npm-image]][npm-url]
+[![code coverage][coverage-badge]][coverage]
+[![Node.js CI](https://github.com/eggjs/supertest/actions/workflows/nodejs.yml/badge.svg)](https://github.com/eggjs/supertest/actions/workflows/nodejs.yml)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](https://makeapullrequest.com)
+[![MIT License][license-badge]][license]
+[![npm download][download-image]][download-url]
+[![Node.js Version](https://img.shields.io/node/v/@eggjs/mock.svg?style=flat)](https://nodejs.org/en/download/)
+
+[npm-image]: https://img.shields.io/npm/v/@eggjs/supertest.svg?style=flat-square
+[npm-url]: https://npmjs.org/package/@eggjs/supertest
+[coverage-badge]: https://img.shields.io/codecov/c/github/eggjs/supertest.svg
+[coverage]: https://codecov.io/gh/eggjs/supertest
+[license-badge]: https://img.shields.io/badge/license-MIT-blue.svg?style=flat-square
+[license]: https://github.com/eggjs/supertest/blob/master/LICENSE
+[download-image]: https://img.shields.io/npm/dm/@eggjs/supertest.svg?style=flat-square
+[download-url]: https://npmjs.org/package/@eggjs/supertest
+
+> HTTP assertions made easy via [superagent](http://github.com/ladjs/superagent).  Maintained for [Forward Email](https://github.com/forwardemail) and [Lad](https://github.com/ladjs).
+> Forked for TypeScript friendly
+
+Document see [SuperTest](https://ladjs.github.io/superagent/)
+
+## About
+
+The motivation with this module is to provide a high-level abstraction for testing
+HTTP, while still allowing you to drop down to the [lower-level API](https://ladjs.github.io/superagent/) provided by superagent.
+
+## Getting Started
+
+Install SuperTest as an npm module and save it to your package.json file as a development dependency:
+
+```bash
+npm install @eggjs/supertest --save-dev
+```
+
+  Once installed it can now be referenced by simply calling ```require('supertest');```
+
+## Example
+
+You may pass an `http.Server`, or a `Function` to `request()` - if the server is not
+already listening for connections then it is bound to an ephemeral port for you so
+there is no need to keep track of ports.
+
+SuperTest works with any test framework, here is an example without using any
+test framework at all:
+
+```js
+const { request } = require('@eggjs/supertest');
+const express = require('express');
+
+const app = express();
+
+app.get('/user', function(req, res) {
+  res.status(200).json({ name: 'john' });
+});
+
+request(app)
+  .get('/user')
+  .expect('Content-Type', /json/)
+  .expect('Content-Length', '15')
+  .expect(200)
+  .end(function(err, res) {
+    if (err) throw err;
+  });
+```
+
+To enable http2 protocol, simply append an options to `request` or `request.agent`:
+
+```js
+const { request } = require('@eggjs/supertest');
+const express = require('express');
+
+const app = express();
+
+app.get('/user', function(req, res) {
+  res.status(200).json({ name: 'john' });
+});
+
+request(app, { http2: true })
+  .get('/user')
+  .expect('Content-Type', /json/)
+  .expect('Content-Length', '15')
+  .expect(200)
+  .end(function(err, res) {
+    if (err) throw err;
+  });
+
+request.agent(app, { http2: true })
+  .get('/user')
+  .expect('Content-Type', /json/)
+  .expect('Content-Length', '15')
+  .expect(200)
+  .end(function(err, res) {
+    if (err) throw err;
+  });
+```
+
+Here's an example with mocha, note how you can pass `done` straight to any of the `.expect()` calls:
+
+```js
+describe('GET /user', function() {
+  it('responds with json', function(done) {
+    request(app)
+      .get('/user')
+      .set('Accept', 'application/json')
+      .expect('Content-Type', /json/)
+      .expect(200, done);
+  });
+});
+```
+
+You can use `auth` method to pass HTTP username and password in the same way as in the [superagent](http://ladjs.github.io/superagent/#authentication):
+
+```js
+describe('GET /user', function() {
+  it('responds with json', function(done) {
+    request(app)
+      .get('/user')
+      .auth('username', 'password')
+      .set('Accept', 'application/json')
+      .expect('Content-Type', /json/)
+      .expect(200, done);
+  });
+});
+```
+
+One thing to note with the above statement is that superagent now sends any HTTP
+error (anything other than a 2XX response code) to the callback as the first argument if
+you do not add a status code expect (i.e. `.expect(302)`).
+
+If you are using the `.end()` method `.expect()` assertions that fail will
+not throw - they will return the assertion as an error to the `.end()` callback. In
+order to fail the test case, you will need to rethrow or pass `err` to `done()`, as follows:
+
+```js
+describe('POST /users', function() {
+  it('responds with json', function(done) {
+    request(app)
+      .post('/users')
+      .send({name: 'john'})
+      .set('Accept', 'application/json')
+      .expect('Content-Type', /json/)
+      .expect(200)
+      .end(function(err, res) {
+        if (err) return done(err);
+        return done();
+      });
+  });
+});
+```
+
+You can also use promises:
+
+```js
+describe('GET /users', function() {
+  it('responds with json', function() {
+    return request(app)
+      .get('/users')
+      .set('Accept', 'application/json')
+      .expect('Content-Type', /json/)
+      .expect(200)
+      .then(response => {
+         expect(response.body.email).toEqual('foo@bar.com');
+      })
+  });
+});
+```
+
+Or async/await syntax:
+
+```js
+describe('GET /users', function() {
+  it('responds with json', async function() {
+    const response = await request(app)
+      .get('/users')
+      .set('Accept', 'application/json')
+    expect(response.headers["Content-Type"]).toMatch(/json/);
+    expect(response.status).toEqual(200);
+    expect(response.body.email).toEqual('foo@bar.com');
+  });
+});
+```
+
+Expectations are run in the order of definition. This characteristic can be used
+to modify the response body or headers before executing an assertion.
+
+```js
+describe('POST /user', function() {
+  it('user.name should be an case-insensitive match for "john"', function(done) {
+    request(app)
+      .post('/user')
+      .send('name=john') // x-www-form-urlencoded upload
+      .set('Accept', 'application/json')
+      .expect(function(res) {
+        res.body.id = 'some fixed id';
+        res.body.name = res.body.name.toLowerCase();
+      })
+      .expect(200, {
+        id: 'some fixed id',
+        name: 'john'
+      }, done);
+  });
+});
+```
+
+Anything you can do with superagent, you can do with supertest - for example multipart file uploads!
+
+```js
+request(app)
+  .post('/')
+  .field('name', 'my awesome avatar')
+  .field('complex_object', '{"attribute": "value"}', {contentType: 'application/json'})
+  .attach('avatar', 'test/fixtures/avatar.jpg')
+  ...
+```
+
+Passing the app or url each time is not necessary, if you're testing
+the same host you may simply re-assign the request variable with the
+initialization app or url, a new `Test` is created per `request.VERB()` call.
+
+```js
+t = request('http://localhost:5555');
+
+t.get('/').expect(200, function(err){
+  console.log(err);
+});
+
+t.get('/').expect('heya', function(err){
+  console.log(err);
+});
+```
+
+Here's an example with mocha that shows how to persist a request and its cookies:
+
+```js
+const { agent } = require('@eggjs/supertest');
+const should = require('should');
+const express = require('express');
+const cookieParser = require('cookie-parser');
+
+describe('request.agent(app)', function() {
+  const app = express();
+  app.use(cookieParser());
+
+  app.get('/', function(req, res) {
+    res.cookie('cookie', 'hey');
+    res.send();
+  });
+
+  app.get('/return', function(req, res) {
+    if (req.cookies.cookie) res.send(req.cookies.cookie);
+    else res.send(':(')
+  });
+
+  const testAgent = agent(app);
+
+  it('should save cookies', function(done) {
+    testAgent
+    .get('/')
+    .expect('set-cookie', 'cookie=hey; Path=/', done);
+  });
+
+  it('should send cookies', function(done) {
+    testAgent
+    .get('/return')
+    .expect('hey', done);
+  });
+});
+```
+
+There is another example that is introduced by the file [agency.js](https://github.com/ladjs/superagent/blob/master/test/node/agency.js)
+
+Here is an example where 2 cookies are set on the request.
+
+```js
+agent(app)
+  .get('/api/content')
+  .set('Cookie', ['nameOne=valueOne;nameTwo=valueTwo'])
+  .send()
+  .expect(200)
+  .end((err, res) => {
+    if (err) {
+      return done(err);
+    }
+    expect(res.text).to.be.equal('hey');
+    return done();
+  });
+```
+
+## API
+
+You may use any [superagent](http://github.com/ladjs/superagent) methods,
+including `.write()`, `.pipe()` etc and perform assertions in the `.end()` callback
+for lower-level needs.
+
+### .expect(status[, fn])
+
+Assert response `status` code.
+
+### .expect(status, body[, fn])
+
+Assert response `status` code and `body`.
+
+### .expect(body[, fn])
+
+Assert response `body` text with a string, regular expression, or
+parsed body object.
+
+### .expect(field, value[, fn])
+
+Assert header `field` `value` with a string or regular expression.
+
+### .expect(function(res) {})
+
+Pass a custom assertion function. It'll be given the response object to check. If the check fails, throw an error.
+
+```js
+request(app)
+  .get('/')
+  .expect(hasPreviousAndNextKeys)
+  .end(done);
+
+function hasPreviousAndNextKeys(res) {
+  if (!('next' in res.body)) throw new Error("missing next key");
+  if (!('prev' in res.body)) throw new Error("missing prev key");
+}
+```
+
+### .end(fn)
+
+Perform the request and invoke `fn(err, res)`.
+
+## Notes
+
+Inspired by [api-easy](https://github.com/flatiron/api-easy) minus vows coupling.
+
+## License
+
+[MIT](LICENSE)
+
+## Contributors
+
+[![Contributors](https://contrib.rocks/image?repo=eggjs/supertest)](https://github.com/eggjs/supertest/graphs/contributors)
+
+Made with [contributors-img](https://contrib.rocks).

package/dist/commonjs/agent.d.ts

@@ -0,0 +1,27 @@
+import type { Server } from 'node:net';
+import { agent as Agent } from 'superagent';
+import { Test } from './test.js';
+import type { AgentOptions, App } from './types.js';
+/**
+ * Initialize a new `TestAgent`.
+ *
+ * @param {Function|Server} app
+ * @param {Object} options
+ */
+export declare class TestAgent extends Agent {
+    #private;
+    app: Server | string;
+    _host: string;
+    constructor(appOrListener: App, options?: AgentOptions);
+    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;
+}
+export declare const proxyAgent: typeof TestAgent;

package/dist/commonjs/agent.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.proxyAgent = exports.TestAgent = void 0;
+const node_http_1 = __importDefault(require("node:http"));
+const node_http2_1 = __importDefault(require("node:http2"));
+const superagent_1 = require("superagent");
+const test_js_1 = require("./test.js");
+/**
+ * Initialize a new `TestAgent`.
+ *
+ * @param {Function|Server} app
+ * @param {Object} options
+ */
+class TestAgent extends superagent_1.agent {
+    app;
+    _host;
+    #http2 = false;
+    constructor(appOrListener, options = {}) {
+        super(options);
+        if (typeof appOrListener === 'function') {
+            if (options.http2) {
+                this.#http2 = true;
+                this.app = node_http2_1.default.createServer(appOrListener); // eslint-disable-line no-param-reassign
+            }
+            else {
+                this.app = node_http_1.default.createServer(appOrListener); // eslint-disable-line no-param-reassign
+            }
+        }
+        else {
+            this.app = appOrListener;
+        }
+    }
+    // set a host name
+    host(host) {
+        this._host = host;
+        return this;
+    }
+    // TestAgent.prototype.del = TestAgent.prototype.delete;
+    _testRequest(method, url) {
+        const req = new test_js_1.Test(this.app, method.toUpperCase(), url);
+        if (this.#http2) {
+            req.http2();
+        }
+        if (this._host) {
+            req.set('host', this._host);
+        }
+        const that = this;
+        // access not internal methods
+        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);
+    }
+}
+exports.TestAgent = TestAgent;
+// allow keep use by `agent()`
+exports.proxyAgent = new Proxy(TestAgent, {
+    apply(target, _, argumentsList) {
+        return new target(argumentsList[0], argumentsList[1]);
+    },
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/commonjs/error/AssertError.d.ts

@@ -0,0 +1,5 @@
+export declare class AssertError extends Error {
+    expected: any;
+    actual: any;
+    constructor(message: string, expected: any, actual: any, options?: ErrorOptions);
+}

package/dist/commonjs/error/AssertError.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssertError = void 0;
+class AssertError 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);
+    }
+}
+exports.AssertError = AssertError;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQXNzZXJ0RXJyb3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZXJyb3IvQXNzZXJ0RXJyb3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsTUFBYSxXQUFZLFNBQVEsS0FBSztJQUNwQyxRQUFRLENBQU07SUFDZCxNQUFNLENBQU07SUFFWixZQUFZLE9BQWUsRUFBRSxRQUFhLEVBQUUsTUFBVyxFQUFFLE9BQXNCO1FBQzdFLEtBQUssQ0FBQyxPQUFPLEVBQUUsT0FBTyxDQUFDLENBQUM7UUFDeEIsSUFBSSxDQUFDLElBQUksR0FBRyxJQUFJLENBQUMsV0FBVyxDQUFDLElBQUksQ0FBQztRQUNsQyxJQUFJLENBQUMsUUFBUSxHQUFHLFFBQVEsQ0FBQztRQUN6QixJQUFJLENBQUMsTUFBTSxHQUFHLE1BQU0sQ0FBQztRQUNyQixLQUFLLENBQUMsaUJBQWlCLENBQUMsSUFBSSxFQUFFLElBQUksQ0FBQyxXQUFXLENBQUMsQ0FBQztJQUNsRCxDQUFDO0NBQ0Y7QUFYRCxrQ0FXQyJ9

package/dist/commonjs/index.d.ts

@@ -0,0 +1,14 @@
+import { Request, RequestOptions } from './request.js';
+import { TestAgent, proxyAgent } from './agent.js';
+import type { App, AgentOptions } from './types.js';
+/**
+ * Test against the given `app`,
+ * returning a new `Test`.
+ */
+export declare function request(app: App, options?: RequestOptions): Request;
+export { Request, RequestOptions, TestAgent, proxyAgent as agent, };
+export * from './test.js';
+declare const _default: ((app: App, options?: RequestOptions) => Request) & {
+    agent: (app: App, options?: AgentOptions) => TestAgent;
+};
+export default _default;

package/dist/commonjs/index.js

@@ -0,0 +1,47 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agent = exports.TestAgent = exports.Request = void 0;
+exports.request = request;
+const request_js_1 = require("./request.js");
+Object.defineProperty(exports, "Request", { enumerable: true, get: function () { return request_js_1.Request; } });
+const agent_js_1 = require("./agent.js");
+Object.defineProperty(exports, "TestAgent", { enumerable: true, get: function () { return agent_js_1.TestAgent; } });
+Object.defineProperty(exports, "agent", { enumerable: true, get: function () { return agent_js_1.proxyAgent; } });
+/**
+ * Test against the given `app`,
+ * returning a new `Test`.
+ */
+function request(app, options = {}) {
+    return new request_js_1.Request(app, options);
+}
+__exportStar(require("./test.js"), exports);
+// import request from '@eggjs/supertest';
+// request()
+exports.default = new Proxy(request, {
+    apply(target, _, argumentsList) {
+        return target(argumentsList[0], argumentsList[1]);
+    },
+    get(target, property, receiver) {
+        // import request from '@eggjs/supertest';
+        // request.agent()
+        if (property === 'agent') {
+            return agent_js_1.proxyAgent;
+        }
+        return Reflect.get(target, property, receiver);
+    },
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFRQSwwQkFFQztBQVZELDZDQUF1RDtBQWFyRCx3RkFiTyxvQkFBTyxPQWFQO0FBWlQseUNBQW1EO0FBYWpELDBGQWJPLG9CQUFTLE9BYVA7QUFHSyxzRkFoQkkscUJBQVUsT0FnQlQ7QUFickI7OztHQUdHO0FBQ0gsU0FBZ0IsT0FBTyxDQUFDLEdBQVEsRUFBRSxVQUEwQixFQUFFO0lBQzVELE9BQU8sSUFBSSxvQkFBTyxDQUFDLEdBQUcsRUFBRSxPQUFPLENBQUMsQ0FBQztBQUNuQyxDQUFDO0FBVUQsNENBQTBCO0FBRTFCLDBDQUEwQztBQUMxQyxZQUFZO0FBQ1osa0JBQWUsSUFBSSxLQUFLLENBQUMsT0FBTyxFQUFFO0lBQ2hDLEtBQUssQ0FBQyxNQUFNLEVBQUUsQ0FBQyxFQUFFLGFBQWE7UUFDNUIsT0FBTyxNQUFNLENBQUMsYUFBYSxDQUFDLENBQUMsQ0FBQyxFQUFFLGFBQWEsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQ3BELENBQUM7SUFDRCxHQUFHLENBQUMsTUFBTSxFQUFFLFFBQVEsRUFBRSxRQUFRO1FBQzVCLDBDQUEwQztRQUMxQyxrQkFBa0I7UUFDbEIsSUFBSSxRQUFRLEtBQUssT0FBTyxFQUFFLENBQUM7WUFDekIsT0FBTyxxQkFBVSxDQUFDO1FBQ3BCLENBQUM7UUFDRCxPQUFPLE9BQU8sQ0FBQyxHQUFHLENBQUMsTUFBTSxFQUFFLFFBQVEsRUFBRSxRQUFRLENBQUMsQ0FBQztJQUNqRCxDQUFDO0NBQ0YsQ0FFQSxDQUFDIn0=

package/dist/commonjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/commonjs/request.d.ts

@@ -0,0 +1,20 @@
+import type { Server } from 'node:net';
+import type { App } from './types.js';
+import { Test } from './test.js';
+export interface RequestOptions {
+    http2?: boolean;
+}
+export 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;
+}

package/dist/commonjs/request.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Request = void 0;
+const node_http_1 = __importDefault(require("node:http"));
+const node_http2_1 = __importDefault(require("node:http2"));
+const test_js_1 = require("./test.js");
+class Request {
+    app;
+    #http2 = false;
+    constructor(appOrListener, options = {}) {
+        if (typeof appOrListener === 'function') {
+            if (options.http2) {
+                this.#http2 = true;
+                this.app = node_http2_1.default.createServer(appOrListener); // eslint-disable-line no-param-reassign
+            }
+            else {
+                this.app = node_http_1.default.createServer(appOrListener); // eslint-disable-line no-param-reassign
+            }
+        }
+        else {
+            this.app = appOrListener;
+        }
+    }
+    _testRequest(method, url) {
+        const req = new test_js_1.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);
+    }
+}
+exports.Request = Request;
+//# sourceMappingURL=data:application/json;base64,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