@depup/supertest 7.2.2-depup.0

package/LICENSE

@@ -0,0 +1,23 @@
+(The MIT License)
+
+Copyright (c) 2014 TJ Holowaychuk <tj@vision-media.ca> and other
+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,471 @@
+# [supertest](https://forwardemail.github.io/superagent/)
+
+[![build status](https://github.com/forwardemail/supertest/actions/workflows/ci.yml/badge.svg)](https://github.com/forwardemail/supertest/actions/workflows/ci.yml)
+[![code coverage](https://img.shields.io/codecov/c/github/ladjs/supertest.svg)](https://codecov.io/gh/ladjs/supertest)
+[![code style](https://img.shields.io/badge/code_style-XO-5ed9c7.svg)](https://github.com/sindresorhus/xo)
+[![styled with prettier](https://img.shields.io/badge/styled_with-prettier-ff69b4.svg)](https://github.com/prettier/prettier)
+[![made with lass](https://img.shields.io/badge/made_with-lass-95CC28.svg)](https://lass.js.org)
+[![license](https://img.shields.io/github/license/ladjs/supertest.svg)](LICENSE)
+
+> 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).
+
+## 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://forwardemail.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 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('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('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](https://forwardemail.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
+request = request('http://localhost:5555');
+
+request.get('/').expect(200, function(err){
+  console.log(err);
+});
+
+request.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 request = require('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 agent = request.agent(app);
+
+  it('should save cookies', function(done) {
+    agent
+    .get('/')
+    .expect('set-cookie', 'cookie=hey; Path=/', done);
+  });
+
+  it('should send cookies', function(done) {
+    agent
+    .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)`.
+
+## Cookies
+
+Here is an example of using the `set` and `not` cookie assertions:
+
+```js
+// setup super-test
+const request = require('supertest');
+const express = require('express');
+const cookies = request.cookies;
+
+// setup express test service
+const app = express();
+
+app.get('/users', function(req, res) {
+  res.cookie('alpha', 'one', { domain: 'domain.com', path: '/', httpOnly: true });
+  res.send(200, { name: 'tobi' });
+});
+
+// test request to service
+request(app)
+  .get('/users')
+  .expect('Content-Type', /json/)
+  .expect('Content-Length', '15')
+  .expect(200)
+  // assert 'alpha' cookie is set with domain, path, and httpOnly options
+  .expect(cookies.set({ name: 'alpha', options: ['domain', 'path', 'httponly'] }))
+  // assert 'bravo' cookie is NOT set
+  .expect(cookies.not('set', { name: 'bravo' }))
+  .end(function(err, res) {
+    if (err) {
+      throw err;
+    }
+  });
+```
+
+It is also possible to chain assertions:
+
+```js
+cookies.set({/* ... */}).not('set', {/* ... */})
+```
+
+### Cookie assertions
+
+Functions and methods are chainable.
+
+#### cookies([secret], [asserts])
+
+Get assertion function for [super-test](https://github.com/visionmedia/supertest) `.expect()` method.
+
+*Arguments*
+
+- `secret` - String or array of strings. Cookie signature secrets.
+- `asserts(req, res)` - Function or array of functions. Failed custom assertions should throw.
+
+#### .set(expects, [assert])
+
+Assert that cookie and options are set.
+
+*Arguments*
+
+- `expects` - Object or array of objects.
+  - `name` - String name of cookie.
+  - `options` - *Optional* array of options.
+- `assert` - *Optional* boolean "assert true" modifier. Default: `true`.
+
+#### .reset(expects, [assert])
+
+Assert that cookie is set and was already set (in request headers).
+
+*Arguments*
+
+- `expects` - Object or array of objects.
+  - `name` - String name of cookie.
+- `assert` - *Optional* boolean "assert true" modifier. Default: `true`.
+
+#### .new(expects, [assert])
+
+Assert that cookie is set and was NOT already set (NOT in request headers).
+
+*Arguments*
+
+- `expects` - Object or array of objects.
+  - `name` - String name of cookie.
+- `assert` - *Optional* boolean "assert true" modifier. Default: `true`.
+
+#### .renew(expects, [assert])
+
+Assert that cookie is set with a strictly greater `expires` or `max-age` than the given value.
+
+*Arguments*
+
+- `expects` - Object or array of objects.
+  - `name` - String name of cookie.
+  - `options` - Object of options. `use one of two options below`
+  - `options`.`expires` - String UTC expiration for original cookie (in request headers).
+  - `options`.`max-age` - Integer ttl in seconds for original cookie (in request headers).
+- `assert` - *Optional* boolean "assert true" modifier. Default: `true`.
+
+#### .contain(expects, [assert])
+
+Assert that cookie is set with value and contains options.
+
+Requires `cookies(secret)` initialization if cookie is signed.
+
+*Arguments*
+
+- `expects` - Object or array of objects.
+  - `name` - String name of cookie.
+  - `value` - *Optional* string unsigned value of cookie.
+  - `options` - *Optional* object of options.
+  - `options`.`domain` - *Optional* string domain.
+  - `options`.`path` - *Optional* string path.
+  - `options`.`expires` - *Optional* string UTC expiration.
+  - `options`.`max-age` - *Optional* integer ttl, in seconds.
+  - `options`.`secure` - *Optional* boolean secure flag.
+  - `options`.`httponly` - *Optional* boolean httpOnly flag.
+- `assert` - *Optional* boolean "assert true" modifier. Default: `true`.
+
+#### .not(method, expects)
+
+Call any cookies assertion method with "assert true" modifier set to `false`.
+
+Syntactic sugar.
+
+*Arguments*
+
+- `method` - String method name. Arguments of method name apply in `expects`.
+- `expects` - Object or array of objects.
+  - `name` - String name of cookie.
+  - `value` - *Optional* string unsigned value of cookie.
+  - `options` - *Optional* object of options.
+
+## Notes
+
+Inspired by [api-easy](https://github.com/flatiron/api-easy) minus vows coupling.
+
+## License
+
+MIT
+
+[coverage-badge]: https://img.shields.io/codecov/c/github/ladjs/supertest.svg
+[coverage]: https://codecov.io/gh/ladjs/supertest
+[travis-badge]: https://travis-ci.org/ladjs/supertest.svg?branch=master
+[travis]: https://travis-ci.org/ladjs/supertest
+[dependencies-badge]: https://david-dm.org/ladjs/supertest/status.svg
+[dependencies]: https://david-dm.org/ladjs/supertest
+[prs-badge]: https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square
+[prs]: http://makeapullrequest.com
+[license-badge]: https://img.shields.io/badge/license-MIT-blue.svg?style=flat-square
+[license]: https://github.com/ladjs/supertest/blob/master/LICENSE

package/index.js

@@ -0,0 +1,67 @@
+'use strict';
+
+/**
+ * Module dependencies.
+ */
+const methods = require('methods');
+let http2;
+try {
+  http2 = require('http2'); // eslint-disable-line global-require
+} catch (_) {
+  // eslint-disable-line no-empty
+}
+const Test = require('./lib/test.js');
+const agent = require('./lib/agent.js');
+const cookies = require('./lib/cookies');
+
+/**
+ * Test against the given `app`,
+ * returning a new `Test`.
+ *
+ * @param {Function|Server|String} app
+ * @return {Test}
+ * @api public
+ */
+module.exports = function(app, options = {}) {
+  const obj = {};
+
+  if (typeof app === 'function') {
+    if (options.http2) {
+      if (!http2) {
+        throw new Error(
+          'supertest: this version of Node.js does not support http2'
+        );
+      }
+    }
+  }
+
+  methods.forEach(function(method) {
+    obj[method] = function(url) {
+      var test = new Test(app, method, url, options.http2);
+      if (options.http2) {
+        test.http2();
+      }
+      return test;
+    };
+  });
+
+  // Support previous use of del
+  obj.del = obj.delete;
+
+  return obj;
+};
+
+/**
+ * Expose `Test`
+ */
+module.exports.Test = Test;
+
+/**
+ * Expose the agent function
+ */
+module.exports.agent = agent;
+
+/**
+ * Expose cookie assertions
+ */
+module.exports.cookies = cookies;

package/lib/agent.js

@@ -0,0 +1,100 @@
+'use strict';
+
+/**
+ * Module dependencies.
+ */
+
+const { agent: Agent } = require('superagent');
+const methods = require('methods');
+const http = require('http');
+let http2;
+try {
+  http2 = require('http2'); // eslint-disable-line global-require
+} catch (_) {
+  // eslint-disable-line no-empty
+}
+const Test = require('./test.js');
+
+/**
+ * Initialize a new `TestAgent`.
+ *
+ * @param {Function|Server} app
+ * @param {Object} options
+ * @api public
+ */
+
+function TestAgent(app, options = {}) {
+  if (!(this instanceof TestAgent)) return new TestAgent(app, options);
+
+  const agent = new Agent(options);
+  Object.assign(this, agent);
+
+  this._options = options;
+
+  if (typeof app === 'function') {
+    if (options.http2) {
+      if (!http2) {
+        throw new Error(
+          'supertest: this version of Node.js does not support http2'
+        );
+      }
+      app = http2.createServer(app); // eslint-disable-line no-param-reassign
+    } else {
+      app = http.createServer(app); // eslint-disable-line no-param-reassign
+    }
+  }
+  this.app = app;
+}
+
+/**
+ * Inherits from `Agent.prototype`.
+ */
+
+Object.setPrototypeOf(TestAgent.prototype, Agent.prototype);
+
+// Preserve the original query method before overriding HTTP methods
+const originalQuery = Agent.prototype.query;
+
+// set a host name
+TestAgent.prototype.host = function(host) {
+  this._host = host;
+  return this;
+};
+
+// override HTTP verb methods
+methods.forEach(function(method) {
+  // Skip 'query' method to prevent overwriting superagent's query functionality
+  if (method === 'query') {
+    return;
+  }
+
+  TestAgent.prototype[method] = function(url, fn) { // eslint-disable-line no-unused-vars
+    const req = new Test(this.app, method.toUpperCase(), url);
+    if (this._options.http2) {
+      req.http2();
+    }
+
+    if (this._host) {
+      req.set('host', this._host);
+    }
+
+    req.on('response', this._saveCookies.bind(this));
+    req.on('redirect', this._saveCookies.bind(this));
+    req.on('redirect', this._attachCookies.bind(this, req));
+    this._setDefaults(req);
+    this._attachCookies(req);
+
+    return req;
+  };
+});
+
+// Restore the original query method
+TestAgent.prototype.query = originalQuery;
+
+TestAgent.prototype.del = TestAgent.prototype.delete;
+
+/**
+ * Expose `Agent`.
+ */
+
+module.exports = TestAgent;