From 484f8904ed2a511310c6c8f513f11260f03aaa4f Mon Sep 17 00:00:00 2001 From: niftylettuce Date: Sat, 8 Aug 2020 19:46:53 -0500 Subject: [PATCH] chore: updated docs --- docs/test.html | 6632 ++++++++++++++++++++++-------------------------- index.html | 2 +- 2 files changed, 3086 insertions(+), 3548 deletions(-) diff --git a/docs/test.html b/docs/test.html index 20d5f08bf..391529fa4 100644 --- a/docs/test.html +++ b/docs/test.html @@ -33,14 +33,14 @@

Agent

assert.equal(0, event_called); return agent .get(`${base}/echo`) - .then(res => { + .then((res) => { assert.equal(1, called); assert.equal(1, event_called); assert.equal('application/json', res.headers.accept); assert.equal('testing', res.headers['x-test']); return agent.get(`${base}/querystring`); }) - .then(res => { + .then((res) => { assert.equal(2, called); assert.equal(2, event_called); assert.deepEqual({ hello: 'world' }, res.body); @@ -54,83 +54,71 @@

request

res.statusCode

should set statusCode
- 
done => {
-      request.get(`${uri}/login`, (err, res) => {
-        try {
-          assert.strictEqual(res.statusCode, 200);
-          done();
-        } catch (err2) {
-          done(err2);
-        }
-      });
-    }
+ 
request.get(`${uri}/login`, (err, res) => {
+  try {
+    assert.strictEqual(res.statusCode, 200);
+    done();
+  } catch (err_) {
+    done(err_);
+  }
+});

should allow the send shorthand

with callback in the method call
- 
done => {
-      request.get(`${uri}/login`, (err, res) => {
-        assert.equal(res.status, 200);
-        done();
-      });
-    }
+ 
request.get(`${uri}/login`, (err, res) => {
+  assert.equal(res.status, 200);
+  done();
+});
with data in the method call
- 
done => {
-      request.post(`${uri}/echo`, { foo: 'bar' }).end((err, res) => {
-        assert.equal('{"foo":"bar"}', res.text);
-        done();
-      });
-    }
+ 
request.post(`${uri}/echo`, { foo: 'bar' }).end((err, res) => {
+  assert.equal('{"foo":"bar"}', res.text);
+  done();
+});
with callback and data in the method call
- 
done => {
-      request.post(`${uri}/echo`, { foo: 'bar' }, (err, res) => {
-        assert.equal('{"foo":"bar"}', res.text);
-        done();
-      });
-    }
+ 
request.post(`${uri}/echo`, { foo: 'bar' }, (err, res) => {
+  assert.equal('{"foo":"bar"}', res.text);
+  done();
+});

with a callback

should invoke .end()
- 
done => {
-      request.get(`${uri}/login`, (err, res) => {
-        try {
-          assert.equal(res.status, 200);
-          done();
-        } catch (err2) {
-          done(err2);
-        }
-      });
-    }
+ 
request.get(`${uri}/login`, (err, res) => {
+  try {
+    assert.equal(res.status, 200);
+    done();
+  } catch (err_) {
+    done(err_);
+  }
+});

.end()

should issue a request
- 
done => {
-      request.get(`${uri}/login`).end((err, res) => {
-        try {
-          assert.equal(res.status, 200);
-          done();
-        } catch (err2) {
-          done(err2);
-        }
-      });
-    }
+ 
request.get(`${uri}/login`).end((err, res) => {
+  try {
+    assert.equal(res.status, 200);
+    done();
+  } catch (err_) {
+    done(err_);
+  }
+});
is optional with a promise
if (typeof Promise === 'undefined') {
   return;
 }
 return request
   .get(`${uri}/login`)
-  .then(res => res.status)
+  .then((res) => res.status)
   .then()
-  .then(status => {
+  .then((status) => {
     assert.equal(200, status, 'Real promises pass results through');
   });
called only once with a promise
@@ -138,8 +126,8 @@

.end()

return; } const req = request.get(`${uri}/unique`); -return Promise.all([req, req, req]).then(results => { - results.forEach(item => { +return Promise.all([req, req, req]).then((results) => { + results.forEach((item) => { assert.equal( item.body, results[0].body, @@ -153,57 +141,53 @@

.end()

res.error

ok
- 
done => {
-      let calledErrorEvent = false;
-      let calledOKHandler = false;
-      request
-        .get(`${uri}/error`)
-        .ok(res => {
-          assert.strictEqual(500, res.status);
-          calledOKHandler = true;
-          return true;
-        })
-        .on('error', err => {
-          calledErrorEvent = true;
-        })
-        .end((err, res) => {
-          try {
-            assert.ifError(err);
-            assert.strictEqual(res.status, 500);
-            assert(!calledErrorEvent);
-            assert(calledOKHandler);
-            done();
-          } catch (err2) {
-            done(err2);
-          }
-        });
-    }
-
should should be an Error object
- 
done => {
-      let calledErrorEvent = false;
-      request
-        .get(`${uri}/error`)
-        .on('error', err => {
-          assert.strictEqual(err.status, 500);
-          calledErrorEvent = true;
-        })
-        .end((err, res) => {
-          try {
-            if (NODE) {
-              res.error.message.should.equal('cannot GET /error (500)');
-            } else {
-              res.error.message.should.equal(`cannot GET ${uri}/error (500)`);
-            }
-            assert.strictEqual(res.error.status, 500);
-            assert(err, 'should have an error for 500');
-            assert.equal(err.message, 'Internal Server Error');
-            assert(calledErrorEvent);
-            done();
-          } catch (err2) {
-            done(err2);
-          }
-        });
-    }
+ 
let calledErrorEvent = false;
+let calledOKHandler = false;
+request
+  .get(`${uri}/error`)
+  .ok((res) => {
+    assert.strictEqual(500, res.status);
+    calledOKHandler = true;
+    return true;
+  })
+  .on('error', (err) => {
+    calledErrorEvent = true;
+  })
+  .end((err, res) => {
+    try {
+      assert.ifError(err);
+      assert.strictEqual(res.status, 500);
+      assert(!calledErrorEvent);
+      assert(calledOKHandler);
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });
+
should be an Error object
+ 
let calledErrorEvent = false;
+request
+  .get(`${uri}/error`)
+  .on('error', (err) => {
+    assert.strictEqual(err.status, 500);
+    calledErrorEvent = true;
+  })
+  .end((err, res) => {
+    try {
+      if (NODE) {
+        res.error.message.should.equal('cannot GET /error (500)');
+      } else {
+        res.error.message.should.equal(`cannot GET ${uri}/error (500)`);
+      }
+      assert.strictEqual(res.error.status, 500);
+      assert(err, 'should have an error for 500');
+      assert.equal(err.message, 'Internal Server Error');
+      assert(calledErrorEvent);
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });
with .then() promise
if (typeof Promise === 'undefined') {
   return;
@@ -212,7 +196,7 @@ 
res.error

   () => {
     assert.fail();
   },
-  err => {
+  (err) => {
     assert.equal(err.message, 'Internal Server Error');
   }
 );
@@ -227,7 +211,7 @@

res.error

() => { assert.fail(); }, - err => { + (err) => { assert.equal(200, err.response.status); assert.equal(err.message, 'OK'); } @@ -245,7 +229,7 @@

res.error

() => { assert.fail(); }, - err => { + (err) => { assert.equal(200, err.response.status); assert.equal(err.message, 'boom'); } @@ -256,309 +240,275 @@

res.error

res.header

should be an object
- 
done => {
-      request.get(`${uri}/login`).end((err, res) => {
-        try {
-          assert.equal('Express', res.header['x-powered-by']);
-          done();
-        } catch (err2) {
-          done(err2);
-        }
-      });
-    }
+ 
request.get(`${uri}/login`).end((err, res) => {
+  try {
+    assert.equal('Express', res.header['x-powered-by']);
+    done();
+  } catch (err_) {
+    done(err_);
+  }
+});

set headers

should only set headers for ownProperties of header
- 
done => {
-      try {
-        request
-          .get(`${uri}/echo-headers`)
-          .set('valid', 'ok')
-          .end((err, res) => {
-            if (
-              !err &&
-              res.body &&
-              res.body.valid &&
-              !res.body.hasOwnProperty('invalid')
-            ) {
-              return done();
-            }
-            done(err || new Error('fail'));
-          });
-      } catch (err) {
-        done(err);
+            
try {
+  request
+    .get(`${uri}/echo-headers`)
+    .set('valid', 'ok')
+    .end((err, res) => {
+      if (
+        !err &&
+        res.body &&
+        res.body.valid &&
+        !res.body.hasOwnProperty('invalid')
+      ) {
+        return done();
       }
-    }

+      done(err || new Error('fail'));
+    });
+} catch (err) {
+  done(err);
+}

res.charset

should be set when present
- 
done => {
-      request.get(`${uri}/login`).end((err, res) => {
-        try {
-          res.charset.should.equal('utf-8');
-          done();
-        } catch (err2) {
-          done(err2);
-        }
-      });
-    }
+ 
request.get(`${uri}/login`).end((err, res) => {
+  try {
+    res.charset.should.equal('utf-8');
+    done();
+  } catch (err_) {
+    done(err_);
+  }
+});

res.statusType

should provide the first digit
- 
done => {
-      request.get(`${uri}/login`).end((err, res) => {
-        try {
-          assert(!err, 'should not have an error for success responses');
-          assert.equal(200, res.status);
-          assert.equal(2, res.statusType);
-          done();
-        } catch (err2) {
-          done(err2);
-        }
-      });
-    }
+ 
request.get(`${uri}/login`).end((err, res) => {
+  try {
+    assert(!err, 'should not have an error for success responses');
+    assert.equal(200, res.status);
+    assert.equal(2, res.statusType);
+    done();
+  } catch (err_) {
+    done(err_);
+  }
+});

res.type

should provide the mime-type void of params
- 
done => {
-      request.get(`${uri}/login`).end((err, res) => {
-        try {
-          res.type.should.equal('text/html');
-          res.charset.should.equal('utf-8');
-          done();
-        } catch (err2) {
-          done(err2);
-        }
-      });
-    }
+ 
request.get(`${uri}/login`).end((err, res) => {
+  try {
+    res.type.should.equal('text/html');
+    res.charset.should.equal('utf-8');
+    done();
+  } catch (err_) {
+    done(err_);
+  }
+});

req.set(field, val)

should set the header field
- 
done => {
-      request
-        .post(`${uri}/echo`)
-        .set('X-Foo', 'bar')
-        .set('X-Bar', 'baz')
-        .end((err, res) => {
-          try {
-            assert.equal('bar', res.header['x-foo']);
-            assert.equal('baz', res.header['x-bar']);
-            done();
-          } catch (err2) {
-            done(err2);
-          }
-        });
-    }
+ 
request
+  .post(`${uri}/echo`)
+  .set('X-Foo', 'bar')
+  .set('X-Bar', 'baz')
+  .end((err, res) => {
+    try {
+      assert.equal('bar', res.header['x-foo']);
+      assert.equal('baz', res.header['x-bar']);
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });

req.set(obj)

should set the header fields
- 
done => {
-      request
-        .post(`${uri}/echo`)
-        .set({ 'X-Foo': 'bar', 'X-Bar': 'baz' })
-        .end((err, res) => {
-          try {
-            assert.equal('bar', res.header['x-foo']);
-            assert.equal('baz', res.header['x-bar']);
-            done();
-          } catch (err2) {
-            done(err2);
-          }
-        });
-    }
+ 
request
+  .post(`${uri}/echo`)
+  .set({ 'X-Foo': 'bar', 'X-Bar': 'baz' })
+  .end((err, res) => {
+    try {
+      assert.equal('bar', res.header['x-foo']);
+      assert.equal('baz', res.header['x-bar']);
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });

req.type(str)

should set the Content-Type
- 
done => {
-      request
-        .post(`${uri}/echo`)
-        .type('text/x-foo')
-        .end((err, res) => {
-          try {
-            res.header['content-type'].should.equal('text/x-foo');
-            done();
-          } catch (err2) {
-            done(err2);
-          }
-        });
-    }
+ 
request
+  .post(`${uri}/echo`)
+  .type('text/x-foo')
+  .end((err, res) => {
+    try {
+      res.header['content-type'].should.equal('text/x-foo');
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });
should map "json"
- 
done => {
-      request
-        .post(`${uri}/echo`)
-        .type('json')
-        .send('{"a": 1}')
-        .end((err, res) => {
-          try {
-            res.should.be.json();
-            done();
-          } catch (err2) {
-            done(err2);
-          }
-        });
-    }
+ 
request
+  .post(`${uri}/echo`)
+  .type('json')
+  .send('{"a": 1}')
+  .end((err, res) => {
+    try {
+      res.should.be.json();
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });
should map "html"
- 
done => {
-      request
-        .post(`${uri}/echo`)
-        .type('html')
-        .end((err, res) => {
-          try {
-            res.header['content-type'].should.equal('text/html');
-            done();
-          } catch (err2) {
-            done(err2);
-          }
-        });
-    }
+ 
request
+  .post(`${uri}/echo`)
+  .type('html')
+  .end((err, res) => {
+    try {
+      res.header['content-type'].should.equal('text/html');
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });

req.accept(str)

should set Accept
- 
done => {
-      request
-        .get(`${uri}/echo`)
-        .accept('text/x-foo')
-        .end((err, res) => {
-          try {
-            res.header.accept.should.equal('text/x-foo');
-            done();
-          } catch (err2) {
-            done(err2);
-          }
-        });
-    }
+ 
request
+  .get(`${uri}/echo`)
+  .accept('text/x-foo')
+  .end((err, res) => {
+    try {
+      res.header.accept.should.equal('text/x-foo');
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });
should map "json"
- 
done => {
-      request
-        .get(`${uri}/echo`)
-        .accept('json')
-        .end((err, res) => {
-          try {
-            res.header.accept.should.equal('application/json');
-            done();
-          } catch (err2) {
-            done(err2);
-          }
-        });
-    }
+ 
request
+  .get(`${uri}/echo`)
+  .accept('json')
+  .end((err, res) => {
+    try {
+      res.header.accept.should.equal('application/json');
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });
should map "xml"
- 
done => {
-      request
-        .get(`${uri}/echo`)
-        .accept('xml')
-        .end((err, res) => {
-          try {
-            // Mime module keeps changing this :(
-            assert(
-              res.header.accept == 'application/xml' ||
-                res.header.accept == 'text/xml'
-            );
-            done();
-          } catch (err2) {
-            done(err2);
-          }
-        });
-    }
+ 
request
+  .get(`${uri}/echo`)
+  .accept('xml')
+  .end((err, res) => {
+    try {
+      // Mime module keeps changing this :(
+      assert(
+        res.header.accept == 'application/xml' ||
+          res.header.accept == 'text/xml'
+      );
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });
should map "html"
- 
done => {
-      request
-        .get(`${uri}/echo`)
-        .accept('html')
-        .end((err, res) => {
-          try {
-            res.header.accept.should.equal('text/html');
-            done();
-          } catch (err2) {
-            done(err2);
-          }
-        });
-    }
+ 
request
+  .get(`${uri}/echo`)
+  .accept('html')
+  .end((err, res) => {
+    try {
+      res.header.accept.should.equal('text/html');
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });

req.send(str)

should write the string
- 
done => {
-      request
-        .post(`${uri}/echo`)
-        .type('json')
-        .send('{"name":"tobi"}')
-        .end((err, res) => {
-          try {
-            res.text.should.equal('{"name":"tobi"}');
-            done();
-          } catch (err2) {
-            done(err2);
-          }
-        });
-    }
+ 
request
+  .post(`${uri}/echo`)
+  .type('json')
+  .send('{"name":"tobi"}')
+  .end((err, res) => {
+    try {
+      res.text.should.equal('{"name":"tobi"}');
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });

req.send(Object)

should default to json
- 
done => {
-      request
-        .post(`${uri}/echo`)
-        .send({ name: 'tobi' })
-        .end((err, res) => {
-          try {
-            res.should.be.json();
-            res.text.should.equal('{"name":"tobi"}');
-            done();
-          } catch (err2) {
-            done(err2);
-          }
-        });
-    }
+ 
request
+  .post(`${uri}/echo`)
+  .send({ name: 'tobi' })
+  .end((err, res) => {
+    try {
+      res.should.be.json();
+      res.text.should.equal('{"name":"tobi"}');
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });

when called several times

should merge the objects
- 
done => {
-        request
-          .post(`${uri}/echo`)
-          .send({ name: 'tobi' })
-          .send({ age: 1 })
-          .end((err, res) => {
-            try {
-              res.should.be.json();
-              if (NODE) {
-                res.buffered.should.be.true();
-              }
-              res.text.should.equal('{"name":"tobi","age":1}');
-              done();
-            } catch (err2) {
-              done(err2);
-            }
-          });
-      }
+ 
request
+  .post(`${uri}/echo`)
+  .send({ name: 'tobi' })
+  .send({ age: 1 })
+  .end((err, res) => {
+    try {
+      res.should.be.json();
+      if (NODE) {
+        res.buffered.should.be.true();
+      }
+      res.text.should.equal('{"name":"tobi","age":1}');
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });
@@ -567,109 +517,95 @@

when called several times

.end(fn)

should check arity
- 
done => {
-      request
-        .post(`${uri}/echo`)
-        .send({ name: 'tobi' })
-        .end((err, res) => {
-          try {
-            assert.ifError(err);
-            res.text.should.equal('{"name":"tobi"}');
-            done();
-          } catch (err2) {
-            done(err2);
-          }
-        });
-    }
+ 
request
+  .post(`${uri}/echo`)
+  .send({ name: 'tobi' })
+  .end((err, res) => {
+    try {
+      assert.ifError(err);
+      res.text.should.equal('{"name":"tobi"}');
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });
should emit request
- 
done => {
-      const req = request.post(`${uri}/echo`);
-      req.on('request', request => {
-        assert.equal(req, request);
-        done();
-      });
-      req.end();
-    }
+ 
const req = request.post(`${uri}/echo`);
+req.on('request', (request) => {
+  assert.equal(req, request);
+  done();
+});
+req.end();
should emit response
- 
done => {
-      request
-        .post(`${uri}/echo`)
-        .send({ name: 'tobi' })
-        .on('response', res => {
-          res.text.should.equal('{"name":"tobi"}');
-          done();
-        })
-        .end();
-    }
+ 
request
+  .post(`${uri}/echo`)
+  .send({ name: 'tobi' })
+  .on('response', (res) => {
+    res.text.should.equal('{"name":"tobi"}');
+    done();
+  })
+  .end();

.then(fulfill, reject)

should support successful fulfills with .then(fulfill)
- 
done => {
-      if (typeof Promise === 'undefined') {
-        return done();
-      }
-      request
-        .post(`${uri}/echo`)
-        .send({ name: 'tobi' })
-        .then(res => {
-          res.type.should.equal('application/json');
-          res.text.should.equal('{"name":"tobi"}');
-          done();
-        });
-    }
+ 
if (typeof Promise === 'undefined') {
+  return done();
+}
+request
+  .post(`${uri}/echo`)
+  .send({ name: 'tobi' })
+  .then((res) => {
+    res.type.should.equal('application/json');
+    res.text.should.equal('{"name":"tobi"}');
+    done();
+  });
should reject an error with .then(null, reject)
- 
done => {
-      if (typeof Promise === 'undefined') {
-        return done();
-      }
-      request.get(`${uri}/error`).then(null, err => {
-        assert.equal(err.status, 500);
-        assert.equal(err.response.text, 'boom');
-        done();
-      });
-    }
+ 
if (typeof Promise === 'undefined') {
+  return done();
+}
+request.get(`${uri}/error`).then(null, (err) => {
+  assert.equal(err.status, 500);
+  assert.equal(err.response.text, 'boom');
+  done();
+});

.catch(reject)

should reject an error with .catch(reject)
- 
done => {
-      if (typeof Promise === 'undefined') {
-        return done();
-      }
-      request.get(`${uri}/error`).catch(err => {
-        assert.equal(err.status, 500);
-        assert.equal(err.response.text, 'boom');
-        done();
-      });
-    }
+ 
if (typeof Promise === 'undefined') {
+  return done();
+}
+request.get(`${uri}/error`).catch((err) => {
+  assert.equal(err.status, 500);
+  assert.equal(err.response.text, 'boom');
+  done();
+});

.abort()

should abort the request
- 
done => {
-      const req = request.get(`${uri}/delay/3000`);
-      req.end((err, res) => {
-        try {
-          assert(false, 'should not complete the request');
-        } catch (err2) {
-          done(err2);
-        }
-      });
-      req.on('error', error => {
-        done(error);
-      });
-      req.on('abort', done);
-      setTimeout(() => {
-        req.abort();
-      }, 500);
-    }
+ 
const req = request.get(`${uri}/delay/3000`);
+req.end((err, res) => {
+  try {
+    assert(false, 'should not complete the request');
+  } catch (err_) {
+    done(err_);
+  }
+});
+req.on('error', (error) => {
+  done(error);
+});
+req.on('abort', done);
+setTimeout(() => {
+  req.abort();
+}, 500);
should abort the promise
const req = request.get(`${uri}/delay/3000`);
 setTimeout(() => {
@@ -679,147 +615,128 @@ 
.abort()

   () => {
     assert.fail('should not complete the request');
   },
-  err => {
+  (err) => {
     assert.equal('ABORTED', err.code);
   }
 );
should allow chaining .abort() several times
- 
done => {
-      const req = request.get(`${uri}/delay/3000`);
-      req.end((err, res) => {
-        try {
-          assert(false, 'should not complete the request');
-        } catch (err2) {
-          done(err2);
-        }
-      });
-      // This also verifies only a single 'done' event is emitted
-      req.on('abort', done);
-      setTimeout(() => {
-        req
-          .abort()
-          .abort()
-          .abort();
-      }, 1000);
-    }
+ 
const req = request.get(`${uri}/delay/3000`);
+req.end((err, res) => {
+  try {
+    assert(false, 'should not complete the request');
+  } catch (err_) {
+    done(err_);
+  }
+});
+// This also verifies only a single 'done' event is emitted
+req.on('abort', done);
+setTimeout(() => {
+  req.abort().abort().abort();
+}, 1000);
should not allow abort then end
- 
done => {
-      request
-        .get(`${uri}/delay/3000`)
-        .abort()
-        .end((err, res) => {
-          done(err ? undefined : new Error('Expected abort error'));
-        });
-    }
+ 
request
+  .get(`${uri}/delay/3000`)
+  .abort()
+  .end((err, res) => {
+    done(err ? undefined : new Error('Expected abort error'));
+  });

req.toJSON()

should describe the request
- 
done => {
-      const req = request.post(`${uri}/echo`).send({ foo: 'baz' });
-      req.end((err, res) => {
-        try {
-          const json = req.toJSON();
-          assert.equal('POST', json.method);
-          assert(/\/echo$/.test(json.url));
-          assert.equal('baz', json.data.foo);
-          done();
-        } catch (err2) {
-          done(err2);
-        }
-      });
-    }
+ 
const req = request.post(`${uri}/echo`).send({ foo: 'baz' });
+req.end((err, res) => {
+  try {
+    const json = req.toJSON();
+    assert.equal('POST', json.method);
+    assert(/\/echo$/.test(json.url));
+    assert.equal('baz', json.data.foo);
+    done();
+  } catch (err_) {
+    done(err_);
+  }
+});

req.options()

should allow request body
- 
done => {
-      request
-        .options(`${uri}/options/echo/body`)
-        .send({ foo: 'baz' })
-        .end((err, res) => {
-          try {
-            assert.equal(err, null);
-            assert.strictEqual(res.body.foo, 'baz');
-            done();
-          } catch (err2) {
-            done(err2);
-          }
-        });
-    }
+ 
request
+  .options(`${uri}/options/echo/body`)
+  .send({ foo: 'baz' })
+  .end((err, res) => {
+    try {
+      assert.equal(err, null);
+      assert.strictEqual(res.body.foo, 'baz');
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });

req.sortQuery()

nop with no querystring
- 
done => {
-      request
-        .get(`${uri}/url`)
-        .sortQuery()
-        .end((err, res) => {
-          try {
-            assert.equal(res.text, '/url');
-            done();
-          } catch (err2) {
-            done(err2);
-          }
-        });
-    }
+ 
request
+  .get(`${uri}/url`)
+  .sortQuery()
+  .end((err, res) => {
+    try {
+      assert.equal(res.text, '/url');
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });
should sort the request querystring
- 
done => {
-      request
-        .get(`${uri}/url`)
-        .query('search=Manny')
-        .query('order=desc')
-        .sortQuery()
-        .end((err, res) => {
-          try {
-            assert.equal(res.text, '/url?order=desc&search=Manny');
-            done();
-          } catch (err2) {
-            done(err2);
-          }
-        });
-    }
+ 
request
+  .get(`${uri}/url`)
+  .query('search=Manny')
+  .query('order=desc')
+  .sortQuery()
+  .end((err, res) => {
+    try {
+      assert.equal(res.text, '/url?order=desc&search=Manny');
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });
should allow disabling sorting
- 
done => {
-      request
-        .get(`${uri}/url`)
-        .query('search=Manny')
-        .query('order=desc')
-        .sortQuery() // take default of true
-        .sortQuery(false) // override it in later call
-        .end((err, res) => {
-          try {
-            assert.equal(res.text, '/url?search=Manny&order=desc');
-            done();
-          } catch (err2) {
-            done(err2);
-          }
-        });
-    }
+ 
request
+  .get(`${uri}/url`)
+  .query('search=Manny')
+  .query('order=desc')
+  .sortQuery() // take default of true
+  .sortQuery(false) // override it in later call
+  .end((err, res) => {
+    try {
+      assert.equal(res.text, '/url?search=Manny&order=desc');
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });
should sort the request querystring using customized function
- 
done => {
-      request
-        .get(`${uri}/url`)
-        .query('name=Nick')
-        .query('search=Manny')
-        .query('order=desc')
-        .sortQuery((a, b) => a.length - b.length)
-        .end((err, res) => {
-          try {
-            assert.equal(res.text, '/url?name=Nick&order=desc&search=Manny');
-            done();
-          } catch (err2) {
-            done(err2);
-          }
-        });
-    }
+ 
request
+  .get(`${uri}/url`)
+  .query('name=Nick')
+  .query('search=Manny')
+  .query('order=desc')
+  .sortQuery((a, b) => a.length - b.length)
+  .end((err, res) => {
+    try {
+      assert.equal(res.text, '/url?name=Nick&order=desc&search=Manny');
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });
@@ -828,27 +745,23 @@

req.sortQuery()

req.set("Content-Type", contentType)

should work with just the contentType component
- 
done => {
-    request
-      .post(`${uri}/echo`)
-      .set('Content-Type', 'application/json')
-      .send({ name: 'tobi' })
-      .end((err, res) => {
-        assert(!err);
-        done();
-      });
-  }
+ 
request
+  .post(`${uri}/echo`)
+  .set('Content-Type', 'application/json')
+  .send({ name: 'tobi' })
+  .end((err, res) => {
+    assert(!err);
+    done();
+  });
should work with the charset component
- 
done => {
-    request
-      .post(`${uri}/echo`)
-      .set('Content-Type', 'application/json; charset=utf-8')
-      .send({ name: 'tobi' })
-      .end((err, res) => {
-        assert(!err);
-        done();
-      });
-  }
+ 
request
+  .post(`${uri}/echo`)
+  .set('Content-Type', 'application/json; charset=utf-8')
+  .send({ name: 'tobi' })
+  .end((err, res) => {
+    assert(!err);
+    done();
+  });
@@ -858,41 +771,37 @@

req.send(Object) as "form"

with req.type() set to form

should send x-www-form-urlencoded data
- 
done => {
-      request
-        .post(`${base}/echo`)
-        .type('form')
-        .send({ name: 'tobi' })
-        .end((err, res) => {
-          res.header['content-type'].should.equal(
-            'application/x-www-form-urlencoded'
-          );
-          res.text.should.equal('name=tobi');
-          done();
-        });
-    }
+ 
request
+  .post(`${base}/echo`)
+  .type('form')
+  .send({ name: 'tobi' })
+  .end((err, res) => {
+    res.header['content-type'].should.equal(
+      'application/x-www-form-urlencoded'
+    );
+    res.text.should.equal('name=tobi');
+    done();
+  });

when called several times

should merge the objects
- 
done => {
-      request
-        .post(`${base}/echo`)
-        .type('form')
-        .send({ name: { first: 'tobi', last: 'holowaychuk' } })
-        .send({ age: '1' })
-        .end((err, res) => {
-          res.header['content-type'].should.equal(
-            'application/x-www-form-urlencoded'
-          );
-          res.text.should.equal(
-            'name%5Bfirst%5D=tobi&name%5Blast%5D=holowaychuk&age=1'
-          );
-          done();
-        });
-    }
+ 
request
+  .post(`${base}/echo`)
+  .type('form')
+  .send({ name: { first: 'tobi', last: 'holowaychuk' } })
+  .send({ age: '1' })
+  .end((err, res) => {
+    res.header['content-type'].should.equal(
+      'application/x-www-form-urlencoded'
+    );
+    res.text.should.equal(
+      'name%5Bfirst%5D=tobi&name%5Blast%5D=holowaychuk&age=1'
+    );
+    done();
+  });
@@ -901,76 +810,66 @@

when called several times

req.attach

ignores null file
- 
done => {
-    request
-      .post('/echo')
-      .attach('image', null)
-      .end((err, res) => {
-        done();
-      });
-  }
+ 
request
+  .post('/echo')
+  .attach('image', null)
+  .end((err, res) => {
+    done();
+  });

req.field

allow bools
- 
done => {
-    if (!formDataSupported) {
-      return done();
-    }
-    request
-      .post(`${base}/formecho`)
-      .field('bools', true)
-      .field('strings', 'true')
-      .end((err, res) => {
-        assert.ifError(err);
-        assert.deepStrictEqual(res.body, { bools: 'true', strings: 'true' });
-        done();
-      });
-  }
+ 
if (!formDataSupported) {
+  return done();
+}
+request
+  .post(`${base}/formecho`)
+  .field('bools', true)
+  .field('strings', 'true')
+  .end((err, res) => {
+    assert.ifError(err);
+    assert.deepStrictEqual(res.body, { bools: 'true', strings: 'true' });
+    done();
+  });
allow objects
- 
done => {
-    if (!formDataSupported) {
-      return done();
-    }
-    request
-      .post(`${base}/formecho`)
-      .field({ bools: true, strings: 'true' })
-      .end((err, res) => {
-        assert.ifError(err);
-        assert.deepStrictEqual(res.body, { bools: 'true', strings: 'true' });
-        done();
-      });
-  }
+ 
if (!formDataSupported) {
+  return done();
+}
+request
+  .post(`${base}/formecho`)
+  .field({ bools: true, strings: 'true' })
+  .end((err, res) => {
+    assert.ifError(err);
+    assert.deepStrictEqual(res.body, { bools: 'true', strings: 'true' });
+    done();
+  });
works with arrays in objects
- 
done => {
-    if (!formDataSupported) {
-      return done();
-    }
-    request
-      .post(`${base}/formecho`)
-      .field({ numbers: [1, 2, 3] })
-      .end((err, res) => {
-        assert.ifError(err);
-        assert.deepStrictEqual(res.body, { numbers: ['1', '2', '3'] });
-        done();
-      });
-  }
+ 
if (!formDataSupported) {
+  return done();
+}
+request
+  .post(`${base}/formecho`)
+  .field({ numbers: [1, 2, 3] })
+  .end((err, res) => {
+    assert.ifError(err);
+    assert.deepStrictEqual(res.body, { numbers: ['1', '2', '3'] });
+    done();
+  });
works with arrays
- 
done => {
-    if (!formDataSupported) {
-      return done();
-    }
-    request
-      .post(`${base}/formecho`)
-      .field('letters', ['a', 'b', 'c'])
-      .end((err, res) => {
-        assert.ifError(err);
-        assert.deepStrictEqual(res.body, { letters: ['a', 'b', 'c'] });
-        done();
-      });
-  }
+ 
if (!formDataSupported) {
+  return done();
+}
+request
+  .post(`${base}/formecho`)
+  .field('letters', ['a', 'b', 'c'])
+  .end((err, res) => {
+    assert.ifError(err);
+    assert.deepStrictEqual(res.body, { letters: ['a', 'b', 'c'] });
+    done();
+  });
throw when empty
should.throws(() => {
   request.post(`${base}/echo`).field();
@@ -980,16 +879,10 @@ 
req.field

 }, /val/);
cannot be mixed with send()
assert.throws(() => {
-  request
-    .post('/echo')
-    .field('form', 'data')
-    .send('hi');
+  request.post('/echo').field('form', 'data').send('hi');
 });
 assert.throws(() => {
-  request
-    .post('/echo')
-    .send('hi')
-    .field('form', 'data');
+  request.post('/echo').send('hi').field('form', 'data');
 });
@@ -997,120 +890,102 @@

req.field

req.send(Object) as "json"

should default to json
- 
done => {
-    request
-      .post(`${uri}/echo`)
-      .send({ name: 'tobi' })
-      .end((err, res) => {
-        res.should.be.json();
-        res.text.should.equal('{"name":"tobi"}');
-        done();
-      });
-  }
+ 
request
+  .post(`${uri}/echo`)
+  .send({ name: 'tobi' })
+  .end((err, res) => {
+    res.should.be.json();
+    res.text.should.equal('{"name":"tobi"}');
+    done();
+  });
should work with arrays
- 
done => {
-    request
-      .post(`${uri}/echo`)
-      .send([1, 2, 3])
-      .end((err, res) => {
-        res.should.be.json();
-        res.text.should.equal('[1,2,3]');
-        done();
-      });
-  }
+ 
request
+  .post(`${uri}/echo`)
+  .send([1, 2, 3])
+  .end((err, res) => {
+    res.should.be.json();
+    res.text.should.equal('[1,2,3]');
+    done();
+  });
should work with value null
- 
done => {
-    request
-      .post(`${uri}/echo`)
-      .type('json')
-      .send('null')
-      .end((err, res) => {
-        res.should.be.json();
-        assert.strictEqual(res.body, null);
-        done();
-      });
-  }
+ 
request
+  .post(`${uri}/echo`)
+  .type('json')
+  .send('null')
+  .end((err, res) => {
+    res.should.be.json();
+    assert.strictEqual(res.body, null);
+    done();
+  });
should work with value false
- 
done => {
-    request
-      .post(`${uri}/echo`)
-      .type('json')
-      .send('false')
-      .end((err, res) => {
-        res.should.be.json();
-        res.body.should.equal(false);
-        done();
-      });
-  }
+ 
request
+  .post(`${uri}/echo`)
+  .type('json')
+  .send('false')
+  .end((err, res) => {
+    res.should.be.json();
+    res.body.should.equal(false);
+    done();
+  });
should work with value 0
- 
done => {
-      // fails in IE9
-      request
-        .post(`${uri}/echo`)
-        .type('json')
-        .send('0')
-        .end((err, res) => {
-          res.should.be.json();
-          res.body.should.equal(0);
-          done();
-        });
-    }
+ 
// fails in IE9
+request
+  .post(`${uri}/echo`)
+  .type('json')
+  .send('0')
+  .end((err, res) => {
+    res.should.be.json();
+    res.body.should.equal(0);
+    done();
+  });
should work with empty string value
- 
done => {
-    request
-      .post(`${uri}/echo`)
-      .type('json')
-      .send('""')
-      .end((err, res) => {
-        res.should.be.json();
-        res.body.should.equal('');
-        done();
-      });
-  }
+ 
request
+  .post(`${uri}/echo`)
+  .type('json')
+  .send('""')
+  .end((err, res) => {
+    res.should.be.json();
+    res.body.should.equal('');
+    done();
+  });
should work with GET
- 
done => {
-      request
-        .get(`${uri}/echo`)
-        .send({ tobi: 'ferret' })
-        .end((err, res) => {
-          try {
-            res.should.be.json();
-            res.text.should.equal('{"tobi":"ferret"}');
-            ({ tobi: 'ferret' }.should.eql(res.body));
-            done();
-          } catch (err2) {
-            done(err2);
-          }
-        });
-    }
+ 
request
+  .get(`${uri}/echo`)
+  .send({ tobi: 'ferret' })
+  .end((err, res) => {
+    try {
+      res.should.be.json();
+      res.text.should.equal('{"tobi":"ferret"}');
+      ({ tobi: 'ferret' }.should.eql(res.body));
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });
should work with vendor MIME type
- 
done => {
-    request
-      .post(`${uri}/echo`)
-      .set('Content-Type', 'application/vnd.example+json')
-      .send({ name: 'vendor' })
-      .end((err, res) => {
-        res.text.should.equal('{"name":"vendor"}');
-        ({ name: 'vendor' }.should.eql(res.body));
-        done();
-      });
-  }
+ 
request
+  .post(`${uri}/echo`)
+  .set('Content-Type', 'application/vnd.example+json')
+  .send({ name: 'vendor' })
+  .end((err, res) => {
+    res.text.should.equal('{"name":"vendor"}');
+    ({ name: 'vendor' }.should.eql(res.body));
+    done();
+  });

when called several times

should merge the objects
- 
done => {
-      request
-        .post(`${uri}/echo`)
-        .send({ name: 'tobi' })
-        .send({ age: 1 })
-        .end((err, res) => {
-          res.should.be.json();
-          res.text.should.equal('{"name":"tobi","age":1}');
-          ({ name: 'tobi', age: 1 }.should.eql(res.body));
-          done();
-        });
-    }
+ 
request
+  .post(`${uri}/echo`)
+  .send({ name: 'tobi' })
+  .send({ age: 1 })
+  .end((err, res) => {
+    res.should.be.json();
+    res.text.should.equal('{"name":"tobi","age":1}');
+    ({ name: 'tobi', age: 1 }.should.eql(res.body));
+    done();
+  });
@@ -1122,98 +997,84 @@

res.body

application/json

should parse the body
- 
done => {
-      request.get(`${uri}/json`).end((err, res) => {
-        res.text.should.equal('{"name":"manny"}');
-        res.body.should.eql({ name: 'manny' });
-        done();
-      });
-    }
+ 
request.get(`${uri}/json`).end((err, res) => {
+  res.text.should.equal('{"name":"manny"}');
+  res.body.should.eql({ name: 'manny' });
+  done();
+});

HEAD requests

should not throw a parse error
- 
done => {
-        request.head(`${uri}/json`).end((err, res) => {
-          try {
-            assert.strictEqual(err, null);
-            assert.strictEqual(res.text, undefined);
-            assert.strictEqual(Object.keys(res.body).length, 0);
-            done();
-          } catch (err2) {
-            done(err2);
-          }
-        });
-      }
+ 
request.head(`${uri}/json`).end((err, res) => {
+  try {
+    assert.strictEqual(err, null);
+    assert.strictEqual(res.text, undefined);
+    assert.strictEqual(Object.keys(res.body).length, 0);
+    done();
+  } catch (err_) {
+    done(err_);
+  }
+});

Invalid JSON response

should return the raw response
- 
done => {
-      request.get(`${uri}/invalid-json`).end((err, res) => {
-        assert.deepEqual(
-          err.rawResponse,
-          ")]}', {'header':{'code':200,'text':'OK','version':'1.0'},'data':'some data'}"
-        );
-        done();
-      });
-    }
+ 
request.get(`${uri}/invalid-json`).end((err, res) => {
+  assert.deepEqual(
+    err.rawResponse,
+    ")]}', {'header':{'code':200,'text':'OK','version':'1.0'},'data':'some data'}"
+  );
+  done();
+});
should return the http status code
- 
done => {
-      request.get(`${uri}/invalid-json-forbidden`).end((err, res) => {
-        assert.equal(err.statusCode, 403);
-        done();
-      });
-    }
+ 
request.get(`${uri}/invalid-json-forbidden`).end((err, res) => {
+  assert.equal(err.statusCode, 403);
+  done();
+});

No content

should not throw a parse error
- 
done => {
-        request.get(`${uri}/no-content`).end((err, res) => {
-          try {
-            assert.strictEqual(err, null);
-            assert.strictEqual(res.text, '');
-            assert.strictEqual(Object.keys(res.body).length, 0);
-            done();
-          } catch (err2) {
-            done(err2);
-          }
-        });
-      }
+ 
request.get(`${uri}/no-content`).end((err, res) => {
+  try {
+    assert.strictEqual(err, null);
+    assert.strictEqual(res.text, '');
+    assert.strictEqual(Object.keys(res.body).length, 0);
+    done();
+  } catch (err_) {
+    done(err_);
+  }
+});

application/json+hal

should parse the body
- 
done => {
-        request.get(`${uri}/json-hal`).end((err, res) => {
-          if (err) return done(err);
-          res.text.should.equal('{"name":"hal 5000"}');
-          res.body.should.eql({ name: 'hal 5000' });
-          done();
-        });
-      }
+ 
request.get(`${uri}/json-hal`).end((err, res) => {
+  if (err) return done(err);
+  res.text.should.equal('{"name":"hal 5000"}');
+  res.body.should.eql({ name: 'hal 5000' });
+  done();
+});

vnd.collection+json

should parse the body
- 
done => {
-        request.get(`${uri}/collection-json`).end((err, res) => {
-          res.text.should.equal('{"name":"chewbacca"}');
-          res.body.should.eql({ name: 'chewbacca' });
-          done();
-        });
-      }
+ 
request.get(`${uri}/collection-json`).end((err, res) => {
+  res.text.should.equal('{"name":"chewbacca"}');
+  res.body.should.eql({ name: 'chewbacca' });
+  done();
+});
@@ -1225,131 +1086,117 @@

request

on redirect

should retain header fields
- 
done => {
-      request
-        .get(`${base}/header`)
-        .set('X-Foo', 'bar')
-        .end((err, res) => {
-          try {
-            assert(res.body);
-            res.body.should.have.property('x-foo', 'bar');
-            done();
-          } catch (err2) {
-            done(err2);
-          }
-        });
-    }
+ 
request
+  .get(`${base}/header`)
+  .set('X-Foo', 'bar')
+  .end((err, res) => {
+    try {
+      assert(res.body);
+      res.body.should.have.property('x-foo', 'bar');
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });
should preserve timeout across redirects
- 
done => {
-      request
-        .get(`${base}/movies/random`)
-        .timeout(250)
-        .end((err, res) => {
-          try {
-            assert(err instanceof Error, 'expected an error');
-            err.should.have.property('timeout', 250);
-            done();
-          } catch (err2) {
-            done(err2);
-          }
-        });
-    }
+ 
request
+  .get(`${base}/movies/random`)
+  .timeout(250)
+  .end((err, res) => {
+    try {
+      assert(err instanceof Error, 'expected an error');
+      err.should.have.property('timeout', 250);
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });
should successfully redirect after retry on error
- 
done => {
-      const id = Math.random() * 1000000 * Date.now();
-      request
-        .get(`${base}/error/redirect/${id}`)
-        .retry(2)
-        .end((err, res) => {
-          assert(res.ok, 'response should be ok');
-          assert(res.text, 'first movie page');
-          done();
-        });
-    }
+ 
const id = Math.random() * 1000000 * Date.now();
+request
+  .get(`${base}/error/redirect/${id}`)
+  .retry(2)
+  .end((err, res) => {
+    assert(res.ok, 'response should be ok');
+    assert(res.text, 'first movie page');
+    done();
+  });
should preserve retries across redirects
- 
done => {
-      const id = Math.random() * 1000000 * Date.now();
-      request
-        .get(`${base}/error/redirect-error${id}`)
-        .retry(2)
-        .end((err, res) => {
-          assert(err, 'expected an error');
-          assert.equal(2, err.retries, 'expected an error with .retries');
-          assert.equal(500, err.status, 'expected an error status of 500');
-          done();
-        });
-    }
+ 
const id = Math.random() * 1000000 * Date.now();
+request
+  .get(`${base}/error/redirect-error${id}`)
+  .retry(2)
+  .end((err, res) => {
+    assert(err, 'expected an error');
+    assert.equal(2, err.retries, 'expected an error with .retries');
+    assert.equal(500, err.status, 'expected an error status of 500');
+    done();
+  });

on 303

should redirect with same method
- 
done => {
-      request
-        .put(`${base}/redirect-303`)
-        .send({ msg: 'hello' })
-        .redirects(1)
-        .on('redirect', res => {
-          res.headers.location.should.equal('/reply-method');
-        })
-        .end((err, res) => {
-          if (err) {
-            done(err);
-            return;
-          }
-          res.text.should.equal('method=get');
-          done();
-        });
-    }
+ 
request
+  .put(`${base}/redirect-303`)
+  .send({ msg: 'hello' })
+  .redirects(1)
+  .on('redirect', (res) => {
+    res.headers.location.should.equal('/reply-method');
+  })
+  .end((err, res) => {
+    if (err) {
+      done(err);
+      return;
+    }
+    res.text.should.equal('method=get');
+    done();
+  });

on 307

should redirect with same method
- 
done => {
-      if (isMSIE) return done(); // IE9 broken
-      request
-        .put(`${base}/redirect-307`)
-        .send({ msg: 'hello' })
-        .redirects(1)
-        .on('redirect', res => {
-          res.headers.location.should.equal('/reply-method');
-        })
-        .end((err, res) => {
-          if (err) {
-            done(err);
-            return;
-          }
-          res.text.should.equal('method=put');
-          done();
-        });
-    }
+ 
if (isMSIE) return done(); // IE9 broken
+request
+  .put(`${base}/redirect-307`)
+  .send({ msg: 'hello' })
+  .redirects(1)
+  .on('redirect', (res) => {
+    res.headers.location.should.equal('/reply-method');
+  })
+  .end((err, res) => {
+    if (err) {
+      done(err);
+      return;
+    }
+    res.text.should.equal('method=put');
+    done();
+  });

on 308

should redirect with same method
- 
done => {
-      if (isMSIE) return done(); // IE9 broken
-      request
-        .put(`${base}/redirect-308`)
-        .send({ msg: 'hello' })
-        .redirects(1)
-        .on('redirect', res => {
-          res.headers.location.should.equal('/reply-method');
-        })
-        .end((err, res) => {
-          if (err) {
-            done(err);
-            return;
-          }
-          res.text.should.equal('method=put');
-          done();
-        });
-    }
+ 
if (isMSIE) return done(); // IE9 broken
+request
+  .put(`${base}/redirect-308`)
+  .send({ msg: 'hello' })
+  .redirects(1)
+  .on('redirect', (res) => {
+    res.headers.location.should.equal('/reply-method');
+  })
+  .end((err, res) => {
+    if (err) {
+      done(err);
+      return;
+    }
+    res.text.should.equal('method=put');
+    done();
+  });
@@ -1360,1217 +1207,1065 @@

request

Request inheritance
assert(request.get(`${uri}/`) instanceof request.Request);
request() simple GET without callback
- 
next => {
-    request('GET', 'test/test.request.js').end();
-    next();
-  }
+ 
request('GET', 'test/test.request.js').end();
+next();
request() simple GET
- 
next => {
-    request('GET', `${uri}/ok`).end((err, res) => {
-      try {
-        assert(res instanceof request.Response, 'respond with Response');
-        assert(res.ok, 'response should be ok');
-        assert(res.text, 'res.text');
-        next();
-      } catch (err2) {
-        next(err2);
-      }
-    });
-  }
+ 
request('GET', `${uri}/ok`).end((err, res) => {
+  try {
+    assert(res instanceof request.Response, 'respond with Response');
+    assert(res.ok, 'response should be ok');
+    assert(res.text, 'res.text');
+    next();
+  } catch (err_) {
+    next(err_);
+  }
+});
request() simple HEAD
- 
next => {
-    request.head(`${uri}/ok`).end((err, res) => {
-      try {
-        assert(res instanceof request.Response, 'respond with Response');
-        assert(res.ok, 'response should be ok');
-        assert(!res.text, 'res.text');
-        next();
-      } catch (err2) {
-        next(err2);
-      }
-    });
-  }
+ 
request.head(`${uri}/ok`).end((err, res) => {
+  try {
+    assert(res instanceof request.Response, 'respond with Response');
+    assert(res.ok, 'response should be ok');
+    assert(!res.text, 'res.text');
+    next();
+  } catch (err_) {
+    next(err_);
+  }
+});
request() GET 5xx
- 
next => {
-    request('GET', `${uri}/error`).end((err, res) => {
-      try {
-        assert(err);
-        assert.equal(err.message, 'Internal Server Error');
-        assert(!res.ok, 'response should not be ok');
-        assert(res.error, 'response should be an error');
-        assert(!res.clientError, 'response should not be a client error');
-        assert(res.serverError, 'response should be a server error');
-        next();
-      } catch (err2) {
-        next(err2);
-      }
-    });
-  }
+ 
request('GET', `${uri}/error`).end((err, res) => {
+  try {
+    assert(err);
+    assert.equal(err.message, 'Internal Server Error');
+    assert(!res.ok, 'response should not be ok');
+    assert(res.error, 'response should be an error');
+    assert(!res.clientError, 'response should not be a client error');
+    assert(res.serverError, 'response should be a server error');
+    next();
+  } catch (err_) {
+    next(err_);
+  }
+});
request() GET 4xx
- 
next => {
-    request('GET', `${uri}/notfound`).end((err, res) => {
-      try {
-        assert(err);
-        assert.equal(err.message, 'Not Found');
-        assert(!res.ok, 'response should not be ok');
-        assert(res.error, 'response should be an error');
-        assert(res.clientError, 'response should be a client error');
-        assert(!res.serverError, 'response should not be a server error');
-        next();
-      } catch (err2) {
-        next(err2);
-      }
-    });
-  }
+ 
request('GET', `${uri}/notfound`).end((err, res) => {
+  try {
+    assert(err);
+    assert.equal(err.message, 'Not Found');
+    assert(!res.ok, 'response should not be ok');
+    assert(res.error, 'response should be an error');
+    assert(res.clientError, 'response should be a client error');
+    assert(!res.serverError, 'response should not be a server error');
+    next();
+  } catch (err_) {
+    next(err_);
+  }
+});
request() GET 404 Not Found
- 
next => {
-    request('GET', `${uri}/notfound`).end((err, res) => {
-      try {
-        assert(err);
-        assert(res.notFound, 'response should be .notFound');
-        next();
-      } catch (err2) {
-        next(err2);
-      }
-    });
-  }
+ 
request('GET', `${uri}/notfound`).end((err, res) => {
+  try {
+    assert(err);
+    assert(res.notFound, 'response should be .notFound');
+    next();
+  } catch (err_) {
+    next(err_);
+  }
+});
request() GET 400 Bad Request
- 
next => {
-    request('GET', `${uri}/bad-request`).end((err, res) => {
-      try {
-        assert(err);
-        assert(res.badRequest, 'response should be .badRequest');
-        next();
-      } catch (err2) {
-        next(err2);
-      }
-    });
-  }
+ 
request('GET', `${uri}/bad-request`).end((err, res) => {
+  try {
+    assert(err);
+    assert(res.badRequest, 'response should be .badRequest');
+    next();
+  } catch (err_) {
+    next(err_);
+  }
+});
request() GET 401 Bad Request
- 
next => {
-    request('GET', `${uri}/unauthorized`).end((err, res) => {
-      try {
-        assert(err);
-        assert(res.unauthorized, 'response should be .unauthorized');
-        next();
-      } catch (err2) {
-        next(err2);
-      }
-    });
-  }
+ 
request('GET', `${uri}/unauthorized`).end((err, res) => {
+  try {
+    assert(err);
+    assert(res.unauthorized, 'response should be .unauthorized');
+    next();
+  } catch (err_) {
+    next(err_);
+  }
+});
request() GET 406 Not Acceptable
- 
next => {
-    request('GET', `${uri}/not-acceptable`).end((err, res) => {
-      try {
-        assert(err);
-        assert(res.notAcceptable, 'response should be .notAcceptable');
-        next();
-      } catch (err2) {
-        next(err2);
-      }
-    });
-  }
+ 
request('GET', `${uri}/not-acceptable`).end((err, res) => {
+  try {
+    assert(err);
+    assert(res.notAcceptable, 'response should be .notAcceptable');
+    next();
+  } catch (err_) {
+    next(err_);
+  }
+});
request() GET 204 No Content
- 
next => {
-    request('GET', `${uri}/no-content`).end((err, res) => {
-      try {
-        assert.ifError(err);
-        assert(res.noContent, 'response should be .noContent');
-        next();
-      } catch (err2) {
-        next(err2);
-      }
-    });
-  }
+ 
request('GET', `${uri}/no-content`).end((err, res) => {
+  try {
+    assert.ifError(err);
+    assert(res.noContent, 'response should be .noContent');
+    next();
+  } catch (err_) {
+    next(err_);
+  }
+});
request() DELETE 204 No Content
- 
next => {
-    request('DELETE', `${uri}/no-content`).end((err, res) => {
-      try {
-        assert.ifError(err);
-        assert(res.noContent, 'response should be .noContent');
-        next();
-      } catch (err2) {
-        next(err2);
-      }
-    });
-  }
+ 
request('DELETE', `${uri}/no-content`).end((err, res) => {
+  try {
+    assert.ifError(err);
+    assert(res.noContent, 'response should be .noContent');
+    next();
+  } catch (err_) {
+    next(err_);
+  }
+});
request() header parsing
- 
next => {
-    request('GET', `${uri}/notfound`).end((err, res) => {
-      try {
-        assert(err);
-        assert.equal('text/html; charset=utf-8', res.header['content-type']);
-        assert.equal('Express', res.header['x-powered-by']);
-        next();
-      } catch (err2) {
-        next(err2);
-      }
-    });
-  }
+ 
request('GET', `${uri}/notfound`).end((err, res) => {
+  try {
+    assert(err);
+    assert.equal('text/html; charset=utf-8', res.header['content-type']);
+    assert.equal('Express', res.header['x-powered-by']);
+    next();
+  } catch (err_) {
+    next(err_);
+  }
+});
request() .status
- 
next => {
-    request('GET', `${uri}/notfound`).end((err, res) => {
-      try {
-        assert(err);
-        assert.equal(404, res.status, 'response .status');
-        assert.equal(4, res.statusType, 'response .statusType');
-        next();
-      } catch (err2) {
-        next(err2);
-      }
-    });
-  }
+ 
request('GET', `${uri}/notfound`).end((err, res) => {
+  try {
+    assert(err);
+    assert.equal(404, res.status, 'response .status');
+    assert.equal(4, res.statusType, 'response .statusType');
+    next();
+  } catch (err_) {
+    next(err_);
+  }
+});
get()
- 
next => {
-    request.get(`${uri}/notfound`).end((err, res) => {
-      try {
-        assert(err);
-        assert.equal(404, res.status, 'response .status');
-        assert.equal(4, res.statusType, 'response .statusType');
-        next();
-      } catch (err2) {
-        next(err2);
-      }
-    });
-  }
+ 
request.get(`${uri}/notfound`).end((err, res) => {
+  try {
+    assert(err);
+    assert.equal(404, res.status, 'response .status');
+    assert.equal(4, res.statusType, 'response .statusType');
+    next();
+  } catch (err_) {
+    next(err_);
+  }
+});
put()
- 
next => {
-    request.put(`${uri}/user/12`).end((err, res) => {
-      try {
-        assert.equal('updated', res.text, 'response text');
-        next();
-      } catch (err2) {
-        next(err2);
-      }
-    });
-  }
+ 
request.put(`${uri}/user/12`).end((err, res) => {
+  try {
+    assert.equal('updated', res.text, 'response text');
+    next();
+  } catch (err_) {
+    next(err_);
+  }
+});
put().send()
- 
next => {
-    request
-      .put(`${uri}/user/13/body`)
-      .send({ user: 'new' })
-      .end((err, res) => {
-        try {
-          assert.equal('received new', res.text, 'response text');
-          next();
-        } catch (err2) {
-          next(err2);
-        }
-      });
-  }
+ 
request
+  .put(`${uri}/user/13/body`)
+  .send({ user: 'new' })
+  .end((err, res) => {
+    try {
+      assert.equal('received new', res.text, 'response text');
+      next();
+    } catch (err_) {
+      next(err_);
+    }
+  });
post()
- 
next => {
-    request.post(`${uri}/user`).end((err, res) => {
-      try {
-        assert.equal('created', res.text, 'response text');
-        next();
-      } catch (err2) {
-        next(err2);
-      }
-    });
-  }
+ 
request.post(`${uri}/user`).end((err, res) => {
+  try {
+    assert.equal('created', res.text, 'response text');
+    next();
+  } catch (err_) {
+    next(err_);
+  }
+});
del()
- 
next => {
-    request.del(`${uri}/user/12`).end((err, res) => {
-      try {
-        assert.equal('deleted', res.text, 'response text');
-        next();
-      } catch (err2) {
-        next(err2);
-      }
-    });
-  }
+ 
request.del(`${uri}/user/12`).end((err, res) => {
+  try {
+    assert.equal('deleted', res.text, 'response text');
+    next();
+  } catch (err_) {
+    next(err_);
+  }
+});
delete()
- 
next => {
-    request.delete(`${uri}/user/12`).end((err, res) => {
-      try {
-        assert.equal('deleted', res.text, 'response text');
-        next();
-      } catch (err2) {
-        next(err2);
-      }
-    });
-  }
+ 
request.delete(`${uri}/user/12`).end((err, res) => {
+  try {
+    assert.equal('deleted', res.text, 'response text');
+    next();
+  } catch (err_) {
+    next(err_);
+  }
+});
post() data
- 
next => {
-    request
-      .post(`${uri}/todo/item`)
-      .type('application/octet-stream')
-      .send('tobi')
-      .end((err, res) => {
-        try {
-          assert.equal('added "tobi"', res.text, 'response text');
-          next();
-        } catch (err2) {
-          next(err2);
-        }
-      });
-  }
+ 
request
+  .post(`${uri}/todo/item`)
+  .type('application/octet-stream')
+  .send('tobi')
+  .end((err, res) => {
+    try {
+      assert.equal('added "tobi"', res.text, 'response text');
+      next();
+    } catch (err_) {
+      next(err_);
+    }
+  });
request .type()
- 
next => {
-    request
-      .post(`${uri}/user/12/pet`)
-      .type('urlencoded')
-      .send('pet=tobi')
-      .end((err, res) => {
-        try {
-          assert.equal('added pet "tobi"', res.text, 'response text');
-          next();
-        } catch (err2) {
-          next(err2);
-        }
-      });
-  }
+ 
request
+  .post(`${uri}/user/12/pet`)
+  .type('urlencoded')
+  .send('pet=tobi')
+  .end((err, res) => {
+    try {
+      assert.equal('added pet "tobi"', res.text, 'response text');
+      next();
+    } catch (err_) {
+      next(err_);
+    }
+  });
request .type() with alias
- 
next => {
-    request
-      .post(`${uri}/user/12/pet`)
-      .type('application/x-www-form-urlencoded')
-      .send('pet=tobi')
-      .end((err, res) => {
-        try {
-          assert.equal('added pet "tobi"', res.text, 'response text');
-          next();
-        } catch (err2) {
-          next(err2);
-        }
-      });
-  }
+ 
request
+  .post(`${uri}/user/12/pet`)
+  .type('application/x-www-form-urlencoded')
+  .send('pet=tobi')
+  .end((err, res) => {
+    try {
+      assert.equal('added pet "tobi"', res.text, 'response text');
+      next();
+    } catch (err_) {
+      next(err_);
+    }
+  });
request .get() with no data or callback
- 
next => {
-    request.get(`${uri}/echo-header/content-type`);
-    next();
-  }
+ 
request.get(`${uri}/echo-header/content-type`);
+next();
request .send() with no data only
- 
next => {
-    request
-      .post(`${uri}/user/5/pet`)
-      .type('urlencoded')
-      .send('pet=tobi');
-    next();
-  }
+ 
request.post(`${uri}/user/5/pet`).type('urlencoded').send('pet=tobi');
+next();
request .send() with callback only
- 
next => {
-    request
-      .get(`${uri}/echo-header/accept`)
-      .set('Accept', 'foo/bar')
-      .end((err, res) => {
-        try {
-          assert.equal('foo/bar', res.text);
-          next();
-        } catch (err2) {
-          next(err2);
-        }
-      });
-  }
+ 
request
+  .get(`${uri}/echo-header/accept`)
+  .set('Accept', 'foo/bar')
+  .end((err, res) => {
+    try {
+      assert.equal('foo/bar', res.text);
+      next();
+    } catch (err_) {
+      next(err_);
+    }
+  });
request .accept() with json
- 
next => {
-    request
-      .get(`${uri}/echo-header/accept`)
-      .accept('json')
-      .end((err, res) => {
-        try {
-          assert.equal('application/json', res.text);
-          next();
-        } catch (err2) {
-          next(err2);
-        }
-      });
-  }
+ 
request
+  .get(`${uri}/echo-header/accept`)
+  .accept('json')
+  .end((err, res) => {
+    try {
+      assert.equal('application/json', res.text);
+      next();
+    } catch (err_) {
+      next(err_);
+    }
+  });
request .accept() with application/json
- 
next => {
-    request
-      .get(`${uri}/echo-header/accept`)
-      .accept('application/json')
-      .end((err, res) => {
-        try {
-          assert.equal('application/json', res.text);
-          next();
-        } catch (err2) {
-          next(err2);
-        }
-      });
-  }
+ 
request
+  .get(`${uri}/echo-header/accept`)
+  .accept('application/json')
+  .end((err, res) => {
+    try {
+      assert.equal('application/json', res.text);
+      next();
+    } catch (err_) {
+      next(err_);
+    }
+  });
request .accept() with xml
- 
next => {
-    request
-      .get(`${uri}/echo-header/accept`)
-      .accept('xml')
-      .end((err, res) => {
-        try {
-          // We can't depend on mime module to be consistent with this
-          assert(res.text == 'application/xml' || res.text == 'text/xml');
-          next();
-        } catch (err2) {
-          next(err2);
-        }
-      });
-  }
+ 
request
+  .get(`${uri}/echo-header/accept`)
+  .accept('xml')
+  .end((err, res) => {
+    try {
+      // We can't depend on mime module to be consistent with this
+      assert(res.text == 'application/xml' || res.text == 'text/xml');
+      next();
+    } catch (err_) {
+      next(err_);
+    }
+  });
request .accept() with application/xml
- 
next => {
-    request
-      .get(`${uri}/echo-header/accept`)
-      .accept('application/xml')
-      .end((err, res) => {
-        try {
-          assert.equal('application/xml', res.text);
-          next();
-        } catch (err2) {
-          next(err2);
-        }
-      });
-  }
+ 
request
+  .get(`${uri}/echo-header/accept`)
+  .accept('application/xml')
+  .end((err, res) => {
+    try {
+      assert.equal('application/xml', res.text);
+      next();
+    } catch (err_) {
+      next(err_);
+    }
+  });
request .end()
- 
next => {
-    request
-      .put(`${uri}/echo-header/content-type`)
-      .set('Content-Type', 'text/plain')
-      .send('wahoo')
-      .end((err, res) => {
-        try {
-          assert.equal('text/plain', res.text);
-          next();
-        } catch (err2) {
-          next(err2);
-        }
-      });
-  }
+ 
request
+  .put(`${uri}/echo-header/content-type`)
+  .set('Content-Type', 'text/plain')
+  .send('wahoo')
+  .end((err, res) => {
+    try {
+      assert.equal('text/plain', res.text);
+      next();
+    } catch (err_) {
+      next(err_);
+    }
+  });
request .send()
- 
next => {
-    request
-      .put(`${uri}/echo-header/content-type`)
-      .set('Content-Type', 'text/plain')
-      .send('wahoo')
-      .end((err, res) => {
-        try {
-          assert.equal('text/plain', res.text);
-          next();
-        } catch (err2) {
-          next(err2);
-        }
-      });
-  }
+ 
request
+  .put(`${uri}/echo-header/content-type`)
+  .set('Content-Type', 'text/plain')
+  .send('wahoo')
+  .end((err, res) => {
+    try {
+      assert.equal('text/plain', res.text);
+      next();
+    } catch (err_) {
+      next(err_);
+    }
+  });
request .set()
- 
next => {
-    request
-      .put(`${uri}/echo-header/content-type`)
-      .set('Content-Type', 'text/plain')
-      .send('wahoo')
-      .end((err, res) => {
-        try {
-          assert.equal('text/plain', res.text);
-          next();
-        } catch (err2) {
-          next(err2);
-        }
-      });
-  }
+ 
request
+  .put(`${uri}/echo-header/content-type`)
+  .set('Content-Type', 'text/plain')
+  .send('wahoo')
+  .end((err, res) => {
+    try {
+      assert.equal('text/plain', res.text);
+      next();
+    } catch (err_) {
+      next(err_);
+    }
+  });
request .set(object)
- 
next => {
-    request
-      .put(`${uri}/echo-header/content-type`)
-      .set({ 'Content-Type': 'text/plain' })
-      .send('wahoo')
-      .end((err, res) => {
-        try {
-          assert.equal('text/plain', res.text);
-          next();
-        } catch (err2) {
-          next(err2);
-        }
-      });
-  }
+ 
request
+  .put(`${uri}/echo-header/content-type`)
+  .set({ 'Content-Type': 'text/plain' })
+  .send('wahoo')
+  .end((err, res) => {
+    try {
+      assert.equal('text/plain', res.text);
+      next();
+    } catch (err_) {
+      next(err_);
+    }
+  });
POST urlencoded
- 
next => {
-    request
-      .post(`${uri}/pet`)
-      .type('urlencoded')
-      .send({ name: 'Manny', species: 'cat' })
-      .end((err, res) => {
-        try {
-          assert.equal('added Manny the cat', res.text);
-          next();
-        } catch (err2) {
-          next(err2);
-        }
-      });
-  }
+ 
request
+  .post(`${uri}/pet`)
+  .type('urlencoded')
+  .send({ name: 'Manny', species: 'cat' })
+  .end((err, res) => {
+    try {
+      assert.equal('added Manny the cat', res.text);
+      next();
+    } catch (err_) {
+      next(err_);
+    }
+  });
POST json
- 
next => {
-    request
-      .post(`${uri}/pet`)
-      .type('json')
-      .send({ name: 'Manny', species: 'cat' })
-      .end((err, res) => {
-        try {
-          assert.equal('added Manny the cat', res.text);
-          next();
-        } catch (err2) {
-          next(err2);
-        }
-      });
-  }
+ 
request
+  .post(`${uri}/pet`)
+  .type('json')
+  .send({ name: 'Manny', species: 'cat' })
+  .end((err, res) => {
+    try {
+      assert.equal('added Manny the cat', res.text);
+      next();
+    } catch (err_) {
+      next(err_);
+    }
+  });
POST json array
- 
next => {
-    request
-      .post(`${uri}/echo`)
-      .send([1, 2, 3])
-      .end((err, res) => {
-        try {
-          assert.equal(
-            'application/json',
-            res.header['content-type'].split(';')[0]
-          );
-          assert.equal('[1,2,3]', res.text);
-          next();
-        } catch (err2) {
-          next(err2);
-        }
-      });
-  }
+ 
request
+  .post(`${uri}/echo`)
+  .send([1, 2, 3])
+  .end((err, res) => {
+    try {
+      assert.equal(
+        'application/json',
+        res.header['content-type'].split(';')[0]
+      );
+      assert.equal('[1,2,3]', res.text);
+      next();
+    } catch (err_) {
+      next(err_);
+    }
+  });
POST json default
- 
next => {
-    request
-      .post(`${uri}/pet`)
-      .send({ name: 'Manny', species: 'cat' })
-      .end((err, res) => {
-        try {
-          assert.equal('added Manny the cat', res.text);
-          next();
-        } catch (err2) {
-          next(err2);
-        }
-      });
-  }
+ 
request
+  .post(`${uri}/pet`)
+  .send({ name: 'Manny', species: 'cat' })
+  .end((err, res) => {
+    try {
+      assert.equal('added Manny the cat', res.text);
+      next();
+    } catch (err_) {
+      next(err_);
+    }
+  });
POST json contentType charset
- 
next => {
-    request
-      .post(`${uri}/echo`)
-      .set('Content-Type', 'application/json; charset=UTF-8')
-      .send({ data: ['data1', 'data2'] })
-      .end((err, res) => {
-        try {
-          assert.equal('{"data":["data1","data2"]}', res.text);
-          next();
-        } catch (err2) {
-          next(err2);
-        }
-      });
-  }
+ 
request
+  .post(`${uri}/echo`)
+  .set('Content-Type', 'application/json; charset=UTF-8')
+  .send({ data: ['data1', 'data2'] })
+  .end((err, res) => {
+    try {
+      assert.equal('{"data":["data1","data2"]}', res.text);
+      next();
+    } catch (err_) {
+      next(err_);
+    }
+  });
POST json contentType vendor
- 
next => {
-    request
-      .post(`${uri}/echo`)
-      .set('Content-Type', 'application/vnd.example+json')
-      .send({ data: ['data1', 'data2'] })
-      .end((err, res) => {
-        try {
-          assert.equal('{"data":["data1","data2"]}', res.text);
-          next();
-        } catch (err2) {
-          next(err2);
-        }
-      });
-  }
+ 
request
+  .post(`${uri}/echo`)
+  .set('Content-Type', 'application/vnd.example+json')
+  .send({ data: ['data1', 'data2'] })
+  .end((err, res) => {
+    try {
+      assert.equal('{"data":["data1","data2"]}', res.text);
+      next();
+    } catch (err_) {
+      next(err_);
+    }
+  });
POST multiple .send() calls
- 
next => {
-    request
-      .post(`${uri}/pet`)
-      .send({ name: 'Manny' })
-      .send({ species: 'cat' })
-      .end((err, res) => {
-        try {
-          assert.equal('added Manny the cat', res.text);
-          next();
-        } catch (err2) {
-          next(err2);
-        }
-      });
-  }
+ 
request
+  .post(`${uri}/pet`)
+  .send({ name: 'Manny' })
+  .send({ species: 'cat' })
+  .end((err, res) => {
+    try {
+      assert.equal('added Manny the cat', res.text);
+      next();
+    } catch (err_) {
+      next(err_);
+    }
+  });
POST multiple .send() strings
- 
next => {
-    request
-      .post(`${uri}/echo`)
-      .send('user[name]=tj')
-      .send('user[email]=tj@vision-media.ca')
-      .end((err, res) => {
-        try {
-          assert.equal(
-            'application/x-www-form-urlencoded',
-            res.header['content-type'].split(';')[0]
-          );
-          assert.equal(
-            res.text,
-            'user[name]=tj&user[email]=tj@vision-media.ca'
-          );
-          next();
-        } catch (err2) {
-          next(err2);
-        }
-      });
-  }
+ 
request
+  .post(`${uri}/echo`)
+  .send('user[name]=tj')
+  .send('user[email]=tj@vision-media.ca')
+  .end((err, res) => {
+    try {
+      assert.equal(
+        'application/x-www-form-urlencoded',
+        res.header['content-type'].split(';')[0]
+      );
+      assert.equal(
+        res.text,
+        'user[name]=tj&user[email]=tj@vision-media.ca'
+      );
+      next();
+    } catch (err_) {
+      next(err_);
+    }
+  });
POST with no data
- 
next => {
-    request
-      .post(`${uri}/empty-body`)
-      .send()
-      .end((err, res) => {
-        try {
-          assert.ifError(err);
-          assert(res.noContent, 'response should be .noContent');
-          next();
-        } catch (err2) {
-          next(err2);
-        }
-      });
-  }
+ 
request
+  .post(`${uri}/empty-body`)
+  .send()
+  .end((err, res) => {
+    try {
+      assert.ifError(err);
+      assert(res.noContent, 'response should be .noContent');
+      next();
+    } catch (err_) {
+      next(err_);
+    }
+  });
GET .type
- 
next => {
-    request.get(`${uri}/pets`).end((err, res) => {
-      try {
-        assert.equal('application/json', res.type);
-        next();
-      } catch (err2) {
-        next(err2);
-      }
-    });
-  }
+ 
request.get(`${uri}/pets`).end((err, res) => {
+  try {
+    assert.equal('application/json', res.type);
+    next();
+  } catch (err_) {
+    next(err_);
+  }
+});
GET Content-Type params
- 
next => {
-    request.get(`${uri}/text`).end((err, res) => {
-      try {
-        assert.equal('utf-8', res.charset);
-        next();
-      } catch (err2) {
-        next(err2);
-      }
-    });
-  }
+ 
request.get(`${uri}/text`).end((err, res) => {
+  try {
+    assert.equal('utf-8', res.charset);
+    next();
+  } catch (err_) {
+    next(err_);
+  }
+});
GET json
- 
next => {
-    request.get(`${uri}/pets`).end((err, res) => {
-      try {
-        assert.deepEqual(res.body, ['tobi', 'loki', 'jane']);
-        next();
-      } catch (err2) {
-        next(err2);
-      }
-    });
-  }
+ 
request.get(`${uri}/pets`).end((err, res) => {
+  try {
+    assert.deepEqual(res.body, ['tobi', 'loki', 'jane']);
+    next();
+  } catch (err_) {
+    next(err_);
+  }
+});
GET json-seq
- 
next => {
-    request
-      .get(`${uri}/json-seq`)
-      .buffer()
-      .end((err, res) => {
-        try {
-          assert.ifError(err);
-          assert.deepEqual(res.text, '\u001E{"id":1}\n\u001E{"id":2}\n');
-          next();
-        } catch (err2) {
-          next(err2);
-        }
-      });
-  }
+ 
request
+  .get(`${uri}/json-seq`)
+  .buffer()
+  .end((err, res) => {
+    try {
+      assert.ifError(err);
+      assert.deepEqual(res.text, '\u001E{"id":1}\n\u001E{"id":2}\n');
+      next();
+    } catch (err_) {
+      next(err_);
+    }
+  });
GET x-www-form-urlencoded
- 
next => {
-    request.get(`${uri}/foo`).end((err, res) => {
-      try {
-        assert.deepEqual(res.body, { foo: 'bar' });
-        next();
-      } catch (err2) {
-        next(err2);
-      }
-    });
-  }
+ 
request.get(`${uri}/foo`).end((err, res) => {
+  try {
+    assert.deepEqual(res.body, { foo: 'bar' });
+    next();
+  } catch (err_) {
+    next(err_);
+  }
+});
GET shorthand
- 
next => {
-    request.get(`${uri}/foo`, (err, res) => {
-      try {
-        assert.equal('foo=bar', res.text);
-        next();
-      } catch (err2) {
-        next(err2);
-      }
-    });
-  }
+ 
request.get(`${uri}/foo`, (err, res) => {
+  try {
+    assert.equal('foo=bar', res.text);
+    next();
+  } catch (err_) {
+    next(err_);
+  }
+});
POST shorthand
- 
next => {
-    request.post(`${uri}/user/0/pet`, { pet: 'tobi' }, (err, res) => {
-      try {
-        assert.equal('added pet "tobi"', res.text);
-        next();
-      } catch (err2) {
-        next(err2);
-      }
-    });
-  }
+ 
request.post(`${uri}/user/0/pet`, { pet: 'tobi' }, (err, res) => {
+  try {
+    assert.equal('added pet "tobi"', res.text);
+    next();
+  } catch (err_) {
+    next(err_);
+  }
+});
POST shorthand without callback
- 
next => {
-    request.post(`${uri}/user/0/pet`, { pet: 'tobi' }).end((err, res) => {
-      try {
-        assert.equal('added pet "tobi"', res.text);
-        next();
-      } catch (err2) {
-        next(err2);
-      }
-    });
-  }
+ 
request.post(`${uri}/user/0/pet`, { pet: 'tobi' }).end((err, res) => {
+  try {
+    assert.equal('added pet "tobi"', res.text);
+    next();
+  } catch (err_) {
+    next(err_);
+  }
+});
GET querystring object with array
- 
next => {
-    request
-      .get(`${uri}/querystring`)
-      .query({ val: ['a', 'b', 'c'] })
-      .end((err, res) => {
-        try {
-          assert.deepEqual(res.body, { val: ['a', 'b', 'c'] });
-          next();
-        } catch (err2) {
-          next(err2);
-        }
-      });
-  }
+ 
request
+  .get(`${uri}/querystring`)
+  .query({ val: ['a', 'b', 'c'] })
+  .end((err, res) => {
+    try {
+      assert.deepEqual(res.body, { val: ['a', 'b', 'c'] });
+      next();
+    } catch (err_) {
+      next(err_);
+    }
+  });
GET querystring object with array and primitives
- 
next => {
-    request
-      .get(`${uri}/querystring`)
-      .query({ array: ['a', 'b', 'c'], string: 'foo', number: 10 })
-      .end((err, res) => {
-        try {
-          assert.deepEqual(res.body, {
-            array: ['a', 'b', 'c'],
-            string: 'foo',
-            number: 10
-          });
-          next();
-        } catch (err2) {
-          next(err2);
-        }
-      });
-  }
+ 
request
+  .get(`${uri}/querystring`)
+  .query({ array: ['a', 'b', 'c'], string: 'foo', number: 10 })
+  .end((err, res) => {
+    try {
+      assert.deepEqual(res.body, {
+        array: ['a', 'b', 'c'],
+        string: 'foo',
+        number: 10
+      });
+      next();
+    } catch (err_) {
+      next(err_);
+    }
+  });
GET querystring object with two arrays
- 
next => {
-    request
-      .get(`${uri}/querystring`)
-      .query({ array1: ['a', 'b', 'c'], array2: [1, 2, 3] })
-      .end((err, res) => {
-        try {
-          assert.deepEqual(res.body, {
-            array1: ['a', 'b', 'c'],
-            array2: [1, 2, 3]
-          });
-          next();
-        } catch (err2) {
-          next(err2);
-        }
-      });
-  }
+ 
request
+  .get(`${uri}/querystring`)
+  .query({ array1: ['a', 'b', 'c'], array2: [1, 2, 3] })
+  .end((err, res) => {
+    try {
+      assert.deepEqual(res.body, {
+        array1: ['a', 'b', 'c'],
+        array2: [1, 2, 3]
+      });
+      next();
+    } catch (err_) {
+      next(err_);
+    }
+  });
GET querystring object
- 
next => {
-    request
-      .get(`${uri}/querystring`)
-      .query({ search: 'Manny' })
-      .end((err, res) => {
-        try {
-          assert.deepEqual(res.body, { search: 'Manny' });
-          next();
-        } catch (err2) {
-          next(err2);
-        }
-      });
-  }
+ 
request
+  .get(`${uri}/querystring`)
+  .query({ search: 'Manny' })
+  .end((err, res) => {
+    try {
+      assert.deepEqual(res.body, { search: 'Manny' });
+      next();
+    } catch (err_) {
+      next(err_);
+    }
+  });
GET querystring append original
- 
next => {
-    request
-      .get(`${uri}/querystring?search=Manny`)
-      .query({ range: '1..5' })
-      .end((err, res) => {
-        try {
-          assert.deepEqual(res.body, { search: 'Manny', range: '1..5' });
-          next();
-        } catch (err2) {
-          next(err2);
-        }
-      });
-  }
+ 
request
+  .get(`${uri}/querystring?search=Manny`)
+  .query({ range: '1..5' })
+  .end((err, res) => {
+    try {
+      assert.deepEqual(res.body, { search: 'Manny', range: '1..5' });
+      next();
+    } catch (err_) {
+      next(err_);
+    }
+  });
GET querystring multiple objects
- 
next => {
-    request
-      .get(`${uri}/querystring`)
-      .query({ search: 'Manny' })
-      .query({ range: '1..5' })
-      .query({ order: 'desc' })
-      .end((err, res) => {
-        try {
-          assert.deepEqual(res.body, {
-            search: 'Manny',
-            range: '1..5',
-            order: 'desc'
-          });
-          next();
-        } catch (err2) {
-          next(err2);
-        }
-      });
-  }
+ 
request
+  .get(`${uri}/querystring`)
+  .query({ search: 'Manny' })
+  .query({ range: '1..5' })
+  .query({ order: 'desc' })
+  .end((err, res) => {
+    try {
+      assert.deepEqual(res.body, {
+        search: 'Manny',
+        range: '1..5',
+        order: 'desc'
+      });
+      next();
+    } catch (err_) {
+      next(err_);
+    }
+  });
GET querystring with strings
- 
next => {
-    request
-      .get(`${uri}/querystring`)
-      .query('search=Manny')
-      .query('range=1..5')
-      .query('order=desc')
-      .end((err, res) => {
-        try {
-          assert.deepEqual(res.body, {
-            search: 'Manny',
-            range: '1..5',
-            order: 'desc'
-          });
-          next();
-        } catch (err2) {
-          next(err2);
-        }
-      });
-  }
+ 
request
+  .get(`${uri}/querystring`)
+  .query('search=Manny')
+  .query('range=1..5')
+  .query('order=desc')
+  .end((err, res) => {
+    try {
+      assert.deepEqual(res.body, {
+        search: 'Manny',
+        range: '1..5',
+        order: 'desc'
+      });
+      next();
+    } catch (err_) {
+      next(err_);
+    }
+  });
GET querystring with strings and objects
- 
next => {
-    request
-      .get(`${uri}/querystring`)
-      .query('search=Manny')
-      .query({ order: 'desc', range: '1..5' })
-      .end((err, res) => {
-        try {
-          assert.deepEqual(res.body, {
-            search: 'Manny',
-            range: '1..5',
-            order: 'desc'
-          });
-          next();
-        } catch (err2) {
-          next(err2);
-        }
-      });
-  }
+ 
request
+  .get(`${uri}/querystring`)
+  .query('search=Manny')
+  .query({ order: 'desc', range: '1..5' })
+  .end((err, res) => {
+    try {
+      assert.deepEqual(res.body, {
+        search: 'Manny',
+        range: '1..5',
+        order: 'desc'
+      });
+      next();
+    } catch (err_) {
+      next(err_);
+    }
+  });
GET shorthand payload goes to querystring
- 
next => {
-    request.get(
-      `${uri}/querystring`,
-      { foo: 'FOO', bar: 'BAR' },
-      (err, res) => {
-        try {
-          assert.deepEqual(res.body, { foo: 'FOO', bar: 'BAR' });
-          next();
-        } catch (err2) {
-          next(err2);
-        }
-      }
-    );
-  }
+ 
request.get(
+  `${uri}/querystring`,
+  { foo: 'FOO', bar: 'BAR' },
+  (err, res) => {
+    try {
+      assert.deepEqual(res.body, { foo: 'FOO', bar: 'BAR' });
+      next();
+    } catch (err_) {
+      next(err_);
+    }
+  }
+);
HEAD shorthand payload goes to querystring
- 
next => {
-    request.head(
-      `${uri}/querystring-in-header`,
-      { foo: 'FOO', bar: 'BAR' },
-      (err, res) => {
-        try {
-          assert.deepEqual(JSON.parse(res.headers.query), {
-            foo: 'FOO',
-            bar: 'BAR'
-          });
-          next();
-        } catch (err2) {
-          next(err2);
-        }
-      }
-    );
-  }
-
request(method, url)
- 
next => {
-    request('GET', `${uri}/foo`).end((err, res) => {
-      try {
-        assert.equal('bar', res.body.foo);
-        next();
-      } catch (err2) {
-        next(err2);
-      }
-    });
-  }
+ 
request.head(
+  `${uri}/querystring-in-header`,
+  { foo: 'FOO', bar: 'BAR' },
+  (err, res) => {
+    try {
+      assert.deepEqual(JSON.parse(res.headers.query), {
+        foo: 'FOO',
+        bar: 'BAR'
+      });
+      next();
+    } catch (err_) {
+      next(err_);
+    }
+  }
+);
+
request(method, url)
+ 
request('GET', `${uri}/foo`).end((err, res) => {
+  try {
+    assert.equal('bar', res.body.foo);
+    next();
+  } catch (err_) {
+    next(err_);
+  }
+});
request(url)
- 
next => {
-    request(`${uri}/foo`).end((err, res) => {
-      try {
-        assert.equal('bar', res.body.foo);
-        next();
-      } catch (err2) {
-        next(err2);
-      }
-    });
-  }
+ 
request(`${uri}/foo`).end((err, res) => {
+  try {
+    assert.equal('bar', res.body.foo);
+    next();
+  } catch (err_) {
+    next(err_);
+  }
+});
request(url, fn)
- 
next => {
-    request(`${uri}/foo`, (err, res) => {
-      try {
-        assert.equal('bar', res.body.foo);
-        next();
-      } catch (err2) {
-        next(err2);
-      }
-    });
-  }
+ 
request(`${uri}/foo`, (err, res) => {
+  try {
+    assert.equal('bar', res.body.foo);
+    next();
+  } catch (err_) {
+    next(err_);
+  }
+});
req.timeout(ms)
- 
next => {
-    const req = request.get(`${uri}/delay/3000`).timeout(1000);
-    req.end((err, res) => {
-      try {
-        assert(err, 'error missing');
-        assert.equal(1000, err.timeout, 'err.timeout missing');
-        assert.equal(
-          'Timeout of 1000ms exceeded',
-          err.message,
-          'err.message incorrect'
-        );
-        assert.equal(null, res);
-        assert(req.timedout, true);
-        next();
-      } catch (err2) {
-        next(err2);
-      }
-    });
-  }
+ 
const req = request.get(`${uri}/delay/3000`).timeout(1000);
+req.end((err, res) => {
+  try {
+    assert(err, 'error missing');
+    assert.equal(1000, err.timeout, 'err.timeout missing');
+    assert.equal(
+      'Timeout of 1000ms exceeded',
+      err.message,
+      'err.message incorrect'
+    );
+    assert.equal(null, res);
+    assert(req.timedout, true);
+    next();
+  } catch (err_) {
+    next(err_);
+  }
+});
req.timeout(ms) with redirect
- 
next => {
-    const req = request.get(`${uri}/delay/const`).timeout(1000);
-    req.end((err, res) => {
-      try {
-        assert(err, 'error missing');
-        assert.equal(1000, err.timeout, 'err.timeout missing');
-        assert.equal(
-          'Timeout of 1000ms exceeded',
-          err.message,
-          'err.message incorrect'
-        );
-        assert.equal(null, res);
-        assert(req.timedout, true);
-        next();
-      } catch (err2) {
-        next(err2);
-      }
-    });
-  }
+ 
const req = request.get(`${uri}/delay/const`).timeout(1000);
+req.end((err, res) => {
+  try {
+    assert(err, 'error missing');
+    assert.equal(1000, err.timeout, 'err.timeout missing');
+    assert.equal(
+      'Timeout of 1000ms exceeded',
+      err.message,
+      'err.message incorrect'
+    );
+    assert.equal(null, res);
+    assert(req.timedout, true);
+    next();
+  } catch (err_) {
+    next(err_);
+  }
+});
request event
- 
next => {
-    request
-      .get(`${uri}/foo`)
-      .on('request', req => {
-        try {
-          assert.equal(`${uri}/foo`, req.url);
-          next();
-        } catch (err) {
-          next(err);
-        }
-      })
-      .end();
-  }
+ 
request
+  .get(`${uri}/foo`)
+  .on('request', (req) => {
+    try {
+      assert.equal(`${uri}/foo`, req.url);
+      next();
+    } catch (err) {
+      next(err);
+    }
+  })
+  .end();
response event
- 
next => {
-    request
-      .get(`${uri}/foo`)
-      .on('response', res => {
-        try {
-          assert.equal('bar', res.body.foo);
-          next();
-        } catch (err) {
-          next(err);
-        }
-      })
-      .end();
-  }
+ 
request
+  .get(`${uri}/foo`)
+  .on('response', (res) => {
+    try {
+      assert.equal('bar', res.body.foo);
+      next();
+    } catch (err) {
+      next(err);
+    }
+  })
+  .end();
response should set statusCode
- 
next => {
-    request.get(`${uri}/ok`, (err, res) => {
-      try {
-        assert.strictEqual(res.statusCode, 200);
-        next();
-      } catch (err2) {
-        next(err2);
-      }
-    });
-  }
+ 
request.get(`${uri}/ok`, (err, res) => {
+  try {
+    assert.strictEqual(res.statusCode, 200);
+    next();
+  } catch (err_) {
+    next(err_);
+  }
+});
req.toJSON()
- 
next => {
-    request.get(`${uri}/ok`).end((err, res) => {
-      try {
-        const j = (res.request || res.req).toJSON();
-        ['url', 'method', 'data', 'headers'].forEach(prop => {
-          assert(j.hasOwnProperty(prop));
-        });
-        next();
-      } catch (err2) {
-        next(err2);
-      }
+        
request.get(`${uri}/ok`).end((err, res) => {
+  try {
+    const j = (res.request || res.req).toJSON();
+    ['url', 'method', 'data', 'headers'].forEach((prop) => {
+      assert(j.hasOwnProperty(prop));
     });
-  }

+    next();
+  } catch (err_) {
+    next(err_);
+  }
+});

.retry(count)

should not retry if passed "0"
- 
done => {
-    request
-      .get(`${base}/error`)
-      .retry(0)
-      .end((err, res) => {
-        try {
-          assert(err, 'expected an error');
-          assert.equal(
-            undefined,
-            err.retries,
-            'expected an error without .retries'
-          );
-          assert.equal(500, err.status, 'expected an error status of 500');
-          done();
-        } catch (err2) {
-          done(err2);
-        }
-      });
-  }
+ 
request
+  .get(`${base}/error`)
+  .retry(0)
+  .end((err, res) => {
+    try {
+      assert(err, 'expected an error');
+      assert.equal(
+        undefined,
+        err.retries,
+        'expected an error without .retries'
+      );
+      assert.equal(500, err.status, 'expected an error status of 500');
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });
should not retry if passed an invalid number
- 
done => {
-    request
-      .get(`${base}/error`)
-      .retry(-2)
-      .end((err, res) => {
-        try {
-          assert(err, 'expected an error');
-          assert.equal(
-            undefined,
-            err.retries,
-            'expected an error without .retries'
-          );
-          assert.equal(500, err.status, 'expected an error status of 500');
-          done();
-        } catch (err2) {
-          done(err2);
-        }
-      });
-  }
+ 
request
+  .get(`${base}/error`)
+  .retry(-2)
+  .end((err, res) => {
+    try {
+      assert(err, 'expected an error');
+      assert.equal(
+        undefined,
+        err.retries,
+        'expected an error without .retries'
+      );
+      assert.equal(500, err.status, 'expected an error status of 500');
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });
should not retry if passed undefined
- 
done => {
-    request
-      .get(`${base}/error`)
-      .retry(undefined)
-      .end((err, res) => {
-        try {
-          assert(err, 'expected an error');
-          assert.equal(
-            undefined,
-            err.retries,
-            'expected an error without .retries'
-          );
-          assert.equal(500, err.status, 'expected an error status of 500');
-          done();
-        } catch (err2) {
-          done(err2);
-        }
-      });
-  }
+ 
request
+  .get(`${base}/error`)
+  .retry(undefined)
+  .end((err, res) => {
+    try {
+      assert(err, 'expected an error');
+      assert.equal(
+        undefined,
+        err.retries,
+        'expected an error without .retries'
+      );
+      assert.equal(500, err.status, 'expected an error status of 500');
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });
should handle server error after repeat attempt
- 
done => {
-    request
-      .get(`${base}/error`)
-      .retry(2)
-      .end((err, res) => {
-        try {
-          assert(err, 'expected an error');
-          assert.equal(2, err.retries, 'expected an error with .retries');
-          assert.equal(500, err.status, 'expected an error status of 500');
-          done();
-        } catch (err2) {
-          done(err2);
-        }
-      });
-  }
+ 
request
+  .get(`${base}/error`)
+  .retry(2)
+  .end((err, res) => {
+    try {
+      assert(err, 'expected an error');
+      assert.equal(2, err.retries, 'expected an error with .retries');
+      assert.equal(500, err.status, 'expected an error status of 500');
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });
should retry if passed nothing
- 
done => {
-    request
-      .get(`${base}/error`)
-      .retry()
-      .end((err, res) => {
-        try {
-          assert(err, 'expected an error');
-          assert.equal(1, err.retries, 'expected an error with .retries');
-          assert.equal(500, err.status, 'expected an error status of 500');
-          done();
-        } catch (err2) {
-          done(err2);
-        }
-      });
-  }
+ 
request
+  .get(`${base}/error`)
+  .retry()
+  .end((err, res) => {
+    try {
+      assert(err, 'expected an error');
+      assert.equal(1, err.retries, 'expected an error with .retries');
+      assert.equal(500, err.status, 'expected an error status of 500');
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });
should retry if passed "true"
- 
done => {
-    request
-      .get(`${base}/error`)
-      .retry(true)
-      .end((err, res) => {
-        try {
-          assert(err, 'expected an error');
-          assert.equal(1, err.retries, 'expected an error with .retries');
-          assert.equal(500, err.status, 'expected an error status of 500');
-          done();
-        } catch (err2) {
-          done(err2);
-        }
-      });
-  }
+ 
request
+  .get(`${base}/error`)
+  .retry(true)
+  .end((err, res) => {
+    try {
+      assert(err, 'expected an error');
+      assert.equal(1, err.retries, 'expected an error with .retries');
+      assert.equal(500, err.status, 'expected an error status of 500');
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });
should handle successful request after repeat attempt from server error
- 
done => {
-    request
-      .get(`${base}/error/ok/${uniqid()}`)
-      .query({ qs: 'present' })
-      .retry(2)
-      .end((err, res) => {
-        try {
-          assert.ifError(err);
-          assert(res.ok, 'response should be ok');
-          assert(res.text, 'res.text');
-          done();
-        } catch (err2) {
-          done(err2);
-        }
-      });
-  }
+ 
request
+  .get(`${base}/error/ok/${uniqid()}`)
+  .query({ qs: 'present' })
+  .retry(2)
+  .end((err, res) => {
+    try {
+      assert.ifError(err);
+      assert(res.ok, 'response should be ok');
+      assert(res.text, 'res.text');
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });
should handle server timeout error after repeat attempt
- 
done => {
-    request
-      .get(`${base}/delay/400`)
-      .timeout(200)
-      .retry(2)
-      .end((err, res) => {
-        try {
-          assert(err, 'expected an error');
-          assert.equal(2, err.retries, 'expected an error with .retries');
-          assert.equal(
-            'number',
-            typeof err.timeout,
-            'expected an error with .timeout'
-          );
-          assert.equal('ECONNABORTED', err.code, 'expected abort error code');
-          done();
-        } catch (err2) {
-          done(err2);
-        }
-      });
-  }
+ 
request
+  .get(`${base}/delay/400`)
+  .timeout(200)
+  .retry(2)
+  .end((err, res) => {
+    try {
+      assert(err, 'expected an error');
+      assert.equal(2, err.retries, 'expected an error with .retries');
+      assert.equal(
+        'number',
+        typeof err.timeout,
+        'expected an error with .timeout'
+      );
+      assert.equal('ECONNABORTED', err.code, 'expected abort error code');
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });
should handle successful request after repeat attempt from server timeout
- 
done => {
-    const url = `/delay/1200/ok/${uniqid()}?built=in`;
-    request
-      .get(base + url)
-      .query('string=ified')
-      .query({ json: 'ed' })
-      .timeout(600)
-      .retry(2)
-      .end((err, res) => {
-        try {
-          assert.ifError(err);
-          assert(res.ok, 'response should be ok');
-          assert.equal(res.text, `ok = ${url}&string=ified&json=ed`);
-          done();
-        } catch (err2) {
-          done(err2);
-        }
-      });
-  }
+ 
const url = `/delay/1200/ok/${uniqid()}?built=in`;
+request
+  .get(base + url)
+  .query('string=ified')
+  .query({ json: 'ed' })
+  .timeout(600)
+  .retry(2)
+  .end((err, res) => {
+    try {
+      assert.ifError(err);
+      assert(res.ok, 'response should be ok');
+      assert.equal(res.text, `ok = ${url}&string=ified&json=ed`);
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });
+
should handle successful request after repeat attempt from server timeout when using .then(fulfill, reject)
+ 
const url = `/delay/1200/ok/${uniqid()}?built=in`;
+request
+  .get(base + url)
+  .query('string=ified')
+  .query({ json: 'ed' })
+  .timeout(600)
+  .retry(1)
+  .then((res, err) => {
+    try {
+      assert.ifError(err);
+      assert(res.ok, 'response should be ok');
+      assert.equal(res.text, `ok = ${url}&string=ified&json=ed`);
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });
should correctly abort a retry attempt
- 
done => {
-    let aborted = false;
-    const req = request
-      .get(`${base}/delay/400`)
-      .timeout(200)
-      .retry(2);
-    req.end((err, res) => {
-      try {
-        assert(false, 'should not complete the request');
-      } catch (err2) {
-        done(err2);
-      }
-    });
-    req.on('abort', () => {
-      aborted = true;
-    });
-    setTimeout(() => {
-      req.abort();
-      setTimeout(() => {
-        try {
-          assert(aborted, 'should be aborted');
-          done();
-        } catch (err) {
-          done(err);
-        }
-      }, 150);
-    }, 150);
-  }
+ 
let aborted = false;
+const req = request.get(`${base}/delay/400`).timeout(200).retry(2);
+req.end((err, res) => {
+  try {
+    assert(false, 'should not complete the request');
+  } catch (err_) {
+    done(err_);
+  }
+});
+req.on('abort', () => {
+  aborted = true;
+});
+setTimeout(() => {
+  req.abort();
+  setTimeout(() => {
+    try {
+      assert(aborted, 'should be aborted');
+      done();
+    } catch (err) {
+      done(err);
+    }
+  }, 150);
+}, 150);
should correctly retain header fields
- 
done => {
-    request
-      .get(`${base}/error/ok/${uniqid()}`)
-      .query({ qs: 'present' })
-      .retry(2)
-      .set('X-Foo', 'bar')
-      .end((err, res) => {
-        try {
-          assert.ifError(err);
-          assert(res.body);
-          res.body.should.have.property('x-foo', 'bar');
-          done();
-        } catch (err2) {
-          done(err2);
-        }
-      });
-  }
+ 
request
+  .get(`${base}/error/ok/${uniqid()}`)
+  .query({ qs: 'present' })
+  .retry(2)
+  .set('X-Foo', 'bar')
+  .end((err, res) => {
+    try {
+      assert.ifError(err);
+      assert(res.body);
+      res.body.should.have.property('x-foo', 'bar');
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });
should not retry on 4xx responses
- 
done => {
-    request
-      .get(`${base}/bad-request`)
-      .retry(2)
-      .end((err, res) => {
-        try {
-          assert(err, 'expected an error');
-          assert.equal(0, err.retries, 'expected an error with 0 .retries');
-          assert.equal(400, err.status, 'expected an error status of 400');
-          done();
-        } catch (err2) {
-          done(err2);
-        }
-      });
-  }
+ 
request
+  .get(`${base}/bad-request`)
+  .retry(2)
+  .end((err, res) => {
+    try {
+      assert(err, 'expected an error');
+      assert.equal(0, err.retries, 'expected an error with 0 .retries');
+      assert.equal(400, err.status, 'expected an error status of 400');
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });
should execute callback on retry if passed
- 
done => {
-    let callbackCallCount = 0;
-    function retryCallback(request) {
-      callbackCallCount++;
+        
let callbackCallCount = 0;
+function retryCallback(request) {
+  callbackCallCount++;
+}
+request
+  .get(`${base}/error`)
+  .retry(2, retryCallback)
+  .end((err, res) => {
+    try {
+      assert(err, 'expected an error');
+      assert.equal(2, err.retries, 'expected an error with .retries');
+      assert.equal(500, err.status, 'expected an error status of 500');
+      assert.equal(
+        2,
+        callbackCallCount,
+        'expected the callback to be called on each retry'
+      );
+      done();
+    } catch (err_) {
+      done(err_);
     }
-    request
-      .get(`${base}/error`)
-      .retry(2, retryCallback)
-      .end((err, res) => {
-        try {
-          assert(err, 'expected an error');
-          assert.equal(2, err.retries, 'expected an error with .retries');
-          assert.equal(500, err.status, 'expected an error status of 500');
-          assert.equal(
-            2,
-            callbackCallCount,
-            'expected the callback to be called on each retry'
-          );
-          done();
-        } catch (err2) {
-          done(err2);
-        }
-      });
-  }

+  });
@@ -2580,111 +2275,111 @@

.timeout(ms)

when timeout is exceeded

should error
- 
done => {
-      request
-        .get(`${base}/delay/500`)
-        .timeout(150)
-        .end((err, res) => {
-          assert(err, 'expected an error');
-          assert.equal(
-            'number',
-            typeof err.timeout,
-            'expected an error with .timeout'
-          );
-          assert.equal('ECONNABORTED', err.code, 'expected abort error code');
-          done();
-        });
-    }
+ 
request
+  .get(`${base}/delay/500`)
+  .timeout(150)
+  .end((err, res) => {
+    assert(err, 'expected an error');
+    assert.equal(
+      'number',
+      typeof err.timeout,
+      'expected an error with .timeout'
+    );
+    assert.equal('ECONNABORTED', err.code, 'expected abort error code');
+    done();
+  });
+
should error in promise interface
+ 
request
+  .get(`${base}/delay/500`)
+  .timeout(150)
+  .catch((err) => {
+    assert(err, 'expected an error');
+    assert.equal(
+      'number',
+      typeof err.timeout,
+      'expected an error with .timeout'
+    );
+    assert.equal('ECONNABORTED', err.code, 'expected abort error code');
+    done();
+  });
should handle gzip timeout
- 
done => {
-      request
-        .get(`${base}/delay/zip`)
-        .timeout(150)
-        .end((err, res) => {
-          assert(err, 'expected an error');
-          assert.equal(
-            'number',
-            typeof err.timeout,
-            'expected an error with .timeout'
-          );
-          assert.equal('ECONNABORTED', err.code, 'expected abort error code');
-          done();
-        });
-    }
+ 
request
+  .get(`${base}/delay/zip`)
+  .timeout(150)
+  .end((err, res) => {
+    assert(err, 'expected an error');
+    assert.equal(
+      'number',
+      typeof err.timeout,
+      'expected an error with .timeout'
+    );
+    assert.equal('ECONNABORTED', err.code, 'expected abort error code');
+    done();
+  });
should handle buffer timeout
- 
done => {
-      request
-        .get(`${base}/delay/json`)
-        .buffer(true)
-        .timeout(150)
-        .end((err, res) => {
-          assert(err, 'expected an error');
-          assert.equal(
-            'number',
-            typeof err.timeout,
-            'expected an error with .timeout'
-          );
-          assert.equal('ECONNABORTED', err.code, 'expected abort error code');
-          done();
-        });
-    }
+ 
request
+  .get(`${base}/delay/json`)
+  .buffer(true)
+  .timeout(150)
+  .end((err, res) => {
+    assert(err, 'expected an error');
+    assert.equal(
+      'number',
+      typeof err.timeout,
+      'expected an error with .timeout'
+    );
+    assert.equal('ECONNABORTED', err.code, 'expected abort error code');
+    done();
+  });
should error on deadline
- 
done => {
-      request
-        .get(`${base}/delay/500`)
-        .timeout({ deadline: 150 })
-        .end((err, res) => {
-          assert(err, 'expected an error');
-          assert.equal(
-            'number',
-            typeof err.timeout,
-            'expected an error with .timeout'
-          );
-          assert.equal('ECONNABORTED', err.code, 'expected abort error code');
-          done();
-        });
-    }
+ 
request
+  .get(`${base}/delay/500`)
+  .timeout({ deadline: 150 })
+  .end((err, res) => {
+    assert(err, 'expected an error');
+    assert.equal(
+      'number',
+      typeof err.timeout,
+      'expected an error with .timeout'
+    );
+    assert.equal('ECONNABORTED', err.code, 'expected abort error code');
+    done();
+  });
should support setting individual options
- 
done => {
-      request
-        .get(`${base}/delay/500`)
-        .timeout({ deadline: 10 })
-        .timeout({ response: 99999 })
-        .end((err, res) => {
-          assert(err, 'expected an error');
-          assert.equal('ECONNABORTED', err.code, 'expected abort error code');
-          assert.equal('ETIME', err.errno);
-          done();
-        });
-    }
+ 
request
+  .get(`${base}/delay/500`)
+  .timeout({ deadline: 10 })
+  .timeout({ response: 99999 })
+  .end((err, res) => {
+    assert(err, 'expected an error');
+    assert.equal('ECONNABORTED', err.code, 'expected abort error code');
+    assert.equal('ETIME', err.errno);
+    done();
+  });
should error on response
- 
done => {
-      request
-        .get(`${base}/delay/500`)
-        .timeout({ response: 150 })
-        .end((err, res) => {
-          assert(err, 'expected an error');
-          assert.equal(
-            'number',
-            typeof err.timeout,
-            'expected an error with .timeout'
-          );
-          assert.equal('ECONNABORTED', err.code, 'expected abort error code');
-          assert.equal('ETIMEDOUT', err.errno);
-          done();
-        });
-    }
+ 
request
+  .get(`${base}/delay/500`)
+  .timeout({ response: 150 })
+  .end((err, res) => {
+    assert(err, 'expected an error');
+    assert.equal(
+      'number',
+      typeof err.timeout,
+      'expected an error with .timeout'
+    );
+    assert.equal('ECONNABORTED', err.code, 'expected abort error code');
+    assert.equal('ETIMEDOUT', err.errno);
+    done();
+  });
should accept slow body with fast response
- 
done => {
-      request
-        .get(`${base}/delay/slowbody`)
-        .timeout({ response: 1000 })
-        .on('progress', () => {
-          // This only makes the test faster without relying on arbitrary timeouts
-          request.get(`${base}/delay/slowbody/finish`).end();
-        })
-        .end(done);
-    }
+ 
request
+  .get(`${base}/delay/slowbody`)
+  .timeout({ response: 1000 })
+  .on('progress', () => {
+    // This only makes the test faster without relying on arbitrary timeouts
+    request.get(`${base}/delay/slowbody/finish`).end();
+  })
+  .end(done);
@@ -2696,26 +2391,24 @@

request

use

should use plugin success
- 
done => {
-      const now = `${Date.now()}`;
-      function uuid(req) {
-        req.set('X-UUID', now);
-        return req;
-      }
-      function prefix(req) {
-        req.url = uri + req.url;
-        return req;
-      }
-      request
-        .get('/echo')
-        .use(uuid)
-        .use(prefix)
-        .end((err, res) => {
-          assert.strictEqual(res.statusCode, 200);
-          assert.equal(res.get('X-UUID'), now);
-          done();
-        });
-    }
+ 
const now = `${Date.now()}`;
+function uuid(req) {
+  req.set('X-UUID', now);
+  return req;
+}
+function prefix(req) {
+  req.url = uri + req.url;
+  return req;
+}
+request
+  .get('/echo')
+  .use(uuid)
+  .use(prefix)
+  .end((err, res) => {
+    assert.strictEqual(res.statusCode, 200);
+    assert.equal(res.get('X-UUID'), now);
+    done();
+  });
@@ -2735,7 +2428,7 @@

subclass

OriginalRequest.apply(this, args); } NewRequest.prototype = Object.create(OriginalRequest.prototype); -NewRequest.prototype.send = function() { +NewRequest.prototype.send = function () { sendCalled = true; return this; }; @@ -2764,52 +2457,48 @@

request

persistent agent

should gain a session on POST
- 
agent3.post(`${base}/signin`).then(res => {
+            
agent3.post(`${base}/signin`).then((res) => {
         res.should.have.status(200);
         should.not.exist(res.headers['set-cookie']);
         res.text.should.containEql('dashboard');
       })

             
should start with empty session (set cookies)

-            
done => {
-      agent1.get(`${base}/dashboard`).end((err, res) => {
-        should.exist(err);
-        res.should.have.status(401);
-        should.exist(res.headers['set-cookie']);
-        done();
-      });
-    }

+            
agent1.get(`${base}/dashboard`).end((err, res) => {
+  should.exist(err);
+  res.should.have.status(401);
+  should.exist(res.headers['set-cookie']);
+  done();
+});

             
should gain a session (cookies already set)

-            
agent1.post(`${base}/signin`).then(res => {
+            
agent1.post(`${base}/signin`).then((res) => {
         res.should.have.status(200);
         should.not.exist(res.headers['set-cookie']);
         res.text.should.containEql('dashboard');
       })

             
should persist cookies across requests

-            
agent1.get(`${base}/dashboard`).then(res => {
+            
agent1.get(`${base}/dashboard`).then((res) => {
         res.should.have.status(200);
       })

             
should have the cookie set in the end callback

             
agent4
         .post(`${base}/setcookie`)
         .then(() => agent4.get(`${base}/getcookie`))
-        .then(res => {
+        .then((res) => {
           res.should.have.status(200);
           assert.strictEqual(res.text, 'jar');
         })

             
should not share cookies

-            
done => {
-      agent2.get(`${base}/dashboard`).end((err, res) => {
-        should.exist(err);
-        res.should.have.status(401);
-        done();
-      });
-    }

+            
agent2.get(`${base}/dashboard`).end((err, res) => {
+  should.exist(err);
+  res.should.have.status(401);
+  done();
+});

             
should not lose cookies between agents

-            
agent1.get(`${base}/dashboard`).then(res => {
+            
agent1.get(`${base}/dashboard`).then((res) => {
         res.should.have.status(200);
       })

             
should be able to follow redirects

-            
agent1.get(base).then(res => {
+            
agent1.get(base).then((res) => {
         res.should.have.status(200);
         res.text.should.containEql('dashboard');
       })

@@ -2817,38 +2506,34 @@ 
persistent agent

             
agent1
         .post(`${base}/redirect`)
         .send({ foo: 'bar', baz: 'blaaah' })
-        .then(res => {
+        .then((res) => {
           res.should.have.status(200);
           res.text.should.containEql('simple');
           res.redirects.should.eql([`${base}/simple`]);
         })

             
should be able to limit redirects

-            
done => {
-      agent1
-        .get(base)
-        .redirects(0)
-        .end((err, res) => {
-          should.exist(err);
-          res.should.have.status(302);
-          res.redirects.should.eql([]);
-          res.header.location.should.equal('/dashboard');
-          done();
-        });
-    }

+            
agent1
+  .get(base)
+  .redirects(0)
+  .end((err, res) => {
+    should.exist(err);
+    res.should.have.status(302);
+    res.redirects.should.eql([]);
+    res.header.location.should.equal('/dashboard');
+    done();
+  });

             
should be able to create a new session (clear cookie)

-            
agent1.post(`${base}/signout`).then(res => {
+            
agent1.post(`${base}/signout`).then((res) => {
         res.should.have.status(200);
         should.exist(res.headers['set-cookie']);
       })

             
should regenerate with an empty session

-            
done => {
-      agent1.get(`${base}/dashboard`).end((err, res) => {
-        should.exist(err);
-        res.should.have.status(401);
-        should.not.exist(res.headers['set-cookie']);
-        done();
-      });
-    }

+            
agent1.get(`${base}/dashboard`).end((err, res) => {
+  should.exist(err);
+  res.should.have.status(401);
+  should.not.exist(res.headers['set-cookie']);
+  done();
+});
@@ -2860,45 +2545,39 @@

Basic auth

when credentials are present in url

should set Authorization
- 
done => {
-      const new_url = URL.parse(base);
-      new_url.auth = 'tobi:learnboost';
-      new_url.pathname = '/basic-auth';
-      request.get(URL.format(new_url)).end((err, res) => {
-        res.status.should.equal(200);
-        done();
-      });
-    }
+ 
const new_url = URL.parse(base);
+new_url.auth = 'tobi:learnboost';
+new_url.pathname = '/basic-auth';
+request.get(URL.format(new_url)).end((err, res) => {
+  res.status.should.equal(200);
+  done();
+});

req.auth(user, pass)

should set Authorization
- 
done => {
-      request
-        .get(`${base}/basic-auth`)
-        .auth('tobi', 'learnboost')
-        .end((err, res) => {
-          res.status.should.equal(200);
-          done();
-        });
-    }
+ 
request
+  .get(`${base}/basic-auth`)
+  .auth('tobi', 'learnboost')
+  .end((err, res) => {
+    res.status.should.equal(200);
+    done();
+  });

req.auth(user + ":" + pass)

should set authorization
- 
done => {
-      request
-        .get(`${base}/basic-auth/again`)
-        .auth('tobi')
-        .end((err, res) => {
-          res.status.should.eql(200);
-          done();
-        });
-    }
+ 
request
+  .get(`${base}/basic-auth/again`)
+  .auth('tobi')
+  .end((err, res) => {
+    res.status.should.eql(200);
+    done();
+  });
@@ -2907,37 +2586,33 @@

req.auth(user + ":" + pass)

[node] request

should send body with .get().send()
- 
next => {
-      request
-        .get(`${base}/echo`)
-        .set('Content-Type', 'text/plain')
-        .send('wahoo')
-        .end((err, res) => {
-          try {
-            assert.equal('wahoo', res.text);
-            next();
-          } catch (err2) {
-            next(err2);
-          }
-        });
-    }
+ 
request
+  .get(`${base}/echo`)
+  .set('Content-Type', 'text/plain')
+  .send('wahoo')
+  .end((err, res) => {
+    try {
+      assert.equal('wahoo', res.text);
+      next();
+    } catch (err_) {
+      next(err_);
+    }
+  });

with an url

should preserve the encoding of the url
- 
done => {
-      request.get(`${base}/url?a=(b%29`).end((err, res) => {
-        assert.equal('/url?a=(b%29', res.text);
-        done();
-      });
-    }
+ 
request.get(`${base}/url?a=(b%29`).end((err, res) => {
+  assert.equal('/url?a=(b%29', res.text);
+  done();
+});

with an object

should format the url
- 
request.get(url.parse(`${base}/login`)).then(res => {
+            
request.get(url.parse(`${base}/login`)).then((res) => {
         assert(res.ok);
       })
@@ -2946,7 +2621,7 @@

with an object

without a schema

should default to http
- 
request.get('localhost:5000/login').then(res => {
+            
request.get('localhost:5000/login').then((res) => {
         assert.equal(res.status, 200);
       })
@@ -2958,7 +2633,7 @@

res.toJSON()

request
         .post(`${base}/echo`)
         .send({ foo: 'baz' })
-        .then(res => {
+        .then((res) => {
           const obj = res.toJSON();
           assert.equal('object', typeof obj.header);
           assert.equal('object', typeof obj.req);
@@ -2971,33 +2646,29 @@ 
res.toJSON()

           
res.links

           

             
should default to an empty object

-            
request.get(`${base}/login`).then(res => {
+            
request.get(`${base}/login`).then((res) => {
         res.links.should.eql({});
       })

             
should parse the Link header field

-            
done => {
-      request.get(`${base}/links`).end((err, res) => {
-        res.links.next.should.equal(
-          'https://api.github.com/repos/visionmedia/mocha/issues?page=2'
-        );
-        done();
-      });
-    }

+            
request.get(`${base}/links`).end((err, res) => {
+  res.links.next.should.equal(
+    'https://api.github.com/repos/visionmedia/mocha/issues?page=2'
+  );
+  done();
+});

req.unset(field)

should remove the header field
- 
done => {
-      request
-        .post(`${base}/echo`)
-        .unset('User-Agent')
-        .end((err, res) => {
-          assert.equal(void 0, res.header['user-agent']);
-          done();
-        });
-    }
+ 
request
+  .post(`${base}/echo`)
+  .unset('User-Agent')
+  .end((err, res) => {
+    assert.equal(void 0, res.header['user-agent']);
+    done();
+  });
@@ -3018,183 +2689,160 @@

case-insensitive

req.write(str)

should write the given data
- 
done => {
-      const req = request.post(`${base}/echo`);
-      req.set('Content-Type', 'application/json');
-      assert.equal('boolean', typeof req.write('{"name"'));
-      assert.equal('boolean', typeof req.write(':"tobi"}'));
-      req.end((err, res) => {
-        res.text.should.equal('{"name":"tobi"}');
-        done();
-      });
-    }
+ 
const req = request.post(`${base}/echo`);
+req.set('Content-Type', 'application/json');
+assert.equal('boolean', typeof req.write('{"name"'));
+assert.equal('boolean', typeof req.write(':"tobi"}'));
+req.end((err, res) => {
+  res.text.should.equal('{"name":"tobi"}');
+  done();
+});

req.pipe(stream)

should pipe the response to the given stream
- 
done => {
-      const stream = new EventEmitter();
-      stream.buf = '';
-      stream.writable = true;
-      stream.write = function(chunk) {
-        this.buf += chunk;
-      };
-      stream.end = function() {
-        this.buf.should.equal('{"name":"tobi"}');
-        done();
-      };
-      request
-        .post(`${base}/echo`)
-        .send('{"name":"tobi"}')
-        .pipe(stream);
-    }
+ 
const stream = new EventEmitter();
+stream.buf = '';
+stream.writable = true;
+stream.write = function (chunk) {
+  this.buf += chunk;
+};
+stream.end = function () {
+  this.buf.should.equal('{"name":"tobi"}');
+  done();
+};
+request.post(`${base}/echo`).send('{"name":"tobi"}').pipe(stream);

.buffer()

should enable buffering
- 
done => {
-      request
-        .get(`${base}/custom`)
-        .buffer()
-        .end((err, res) => {
-          assert.ifError(err);
-          assert.equal('custom stuff', res.text);
-          assert(res.buffered);
-          done();
-        });
-    }
+ 
request
+  .get(`${base}/custom`)
+  .buffer()
+  .end((err, res) => {
+    assert.ifError(err);
+    assert.equal('custom stuff', res.text);
+    assert(res.buffered);
+    done();
+  });
should take precedence over request.buffer['someMimeType'] = false
- 
done => {
-      const type = 'application/barbaz';
-      const send = 'some text';
-      request.buffer[type] = false;
-      request
-        .post(`${base}/echo`)
-        .type(type)
-        .send(send)
-        .buffer()
-        .end((err, res) => {
-          delete request.buffer[type];
-          assert.ifError(err);
-          assert.equal(res.type, type);
-          assert.equal(send, res.text);
-          assert(res.buffered);
-          done();
-        });
-    }
+ 
const type = 'application/barbaz';
+const send = 'some text';
+request.buffer[type] = false;
+request
+  .post(`${base}/echo`)
+  .type(type)
+  .send(send)
+  .buffer()
+  .end((err, res) => {
+    delete request.buffer[type];
+    assert.ifError(err);
+    assert.equal(res.type, type);
+    assert.equal(send, res.text);
+    assert(res.buffered);
+    done();
+  });

.buffer(false)

should disable buffering
- 
done => {
-      request
-        .post(`${base}/echo`)
-        .type('application/x-dog')
-        .send('hello this is dog')
-        .buffer(false)
-        .end((err, res) => {
-          assert.ifError(err);
-          assert.equal(null, res.text);
-          res.body.should.eql({});
-          let buf = '';
-          res.setEncoding('utf8');
-          res.on('data', chunk => {
-            buf += chunk;
-          });
-          res.on('end', () => {
-            buf.should.equal('hello this is dog');
-            done();
-          });
-        });
-    }
+ 
request
+  .post(`${base}/echo`)
+  .type('application/x-dog')
+  .send('hello this is dog')
+  .buffer(false)
+  .end((err, res) => {
+    assert.ifError(err);
+    assert.equal(null, res.text);
+    res.body.should.eql({});
+    let buf = '';
+    res.setEncoding('utf8');
+    res.on('data', (chunk) => {
+      buf += chunk;
+    });
+    res.on('end', () => {
+      buf.should.equal('hello this is dog');
+      done();
+    });
+  });
should take precedence over request.buffer['someMimeType'] = true
- 
done => {
-      const type = 'application/foobar';
-      const send = 'hello this is a dog';
-      request.buffer[type] = true;
-      request
-        .post(`${base}/echo`)
-        .type(type)
-        .send(send)
-        .buffer(false)
-        .end((err, res) => {
-          delete request.buffer[type];
-          assert.ifError(err);
-          assert.equal(null, res.text);
-          assert.equal(res.type, type);
-          assert(!res.buffered);
-          res.body.should.eql({});
-          let buf = '';
-          res.setEncoding('utf8');
-          res.on('data', chunk => {
-            buf += chunk;
-          });
-          res.on('end', () => {
-            buf.should.equal(send);
-            done();
-          });
-        });
-    }
+ 
const type = 'application/foobar';
+const send = 'hello this is a dog';
+request.buffer[type] = true;
+request
+  .post(`${base}/echo`)
+  .type(type)
+  .send(send)
+  .buffer(false)
+  .end((err, res) => {
+    delete request.buffer[type];
+    assert.ifError(err);
+    assert.equal(null, res.text);
+    assert.equal(res.type, type);
+    assert(!res.buffered);
+    res.body.should.eql({});
+    let buf = '';
+    res.setEncoding('utf8');
+    res.on('data', (chunk) => {
+      buf += chunk;
+    });
+    res.on('end', () => {
+      buf.should.equal(send);
+      done();
+    });
+  });

.withCredentials()

should not throw an error when using the client-side "withCredentials" method
- 
done => {
-      request
-        .get(`${base}/custom`)
-        .withCredentials()
-        .end((err, res) => {
-          assert.ifError(err);
-          done();
-        });
-    }
+ 
request
+  .get(`${base}/custom`)
+  .withCredentials()
+  .end((err, res) => {
+    assert.ifError(err);
+    done();
+  });

.agent()

should return the defaut agent
- 
done => {
-      const req = request.post(`${base}/echo`);
-      req.agent().should.equal(false);
-      done();
-    }
+ 
const req = request.post(`${base}/echo`);
+req.agent().should.equal(false);
+done();

.agent(undefined)

should set an agent to undefined and ensure it is chainable
- 
done => {
-      const req = request.get(`${base}/echo`);
-      const ret = req.agent(undefined);
-      ret.should.equal(req);
-      assert.strictEqual(req.agent(), undefined);
-      done();
-    }
+ 
const req = request.get(`${base}/echo`);
+const ret = req.agent(undefined);
+ret.should.equal(req);
+assert.strictEqual(req.agent(), undefined);
+done();

.agent(new http.Agent())

should set passed agent
- 
done => {
-      const http = require('http');
-      const req = request.get(`${base}/echo`);
-      const agent = new http.Agent();
-      const ret = req.agent(agent);
-      ret.should.equal(req);
-      req.agent().should.equal(agent);
-      done();
-    }
+ 
const http = require('http');
+const req = request.get(`${base}/echo`);
+const agent = new http.Agent();
+const ret = req.agent(agent);
+ret.should.equal(req);
+req.agent().should.equal(agent);
+done();
@@ -3205,7 +2853,7 @@

with a content type other than application/json or text/*

.post(`${base}/echo`) .type('application/x-dog') .send('hello this is dog') - .then(res => { + .then((res) => { assert.equal(null, res.text); assert.equal(res.body.toString(), 'hello this is dog'); res.buffered.should.be.true; @@ -3216,37 +2864,33 @@

with a content type other than application/json or text/*

content-length

should be set to the byte length of a non-buffer object
- 
done => {
-      const decoder = new StringDecoder('utf8');
-      let img = fs.readFileSync(`${__dirname}/fixtures/test.png`);
-      img = decoder.write(img);
-      request
-        .post(`${base}/echo`)
-        .type('application/x-image')
-        .send(img)
-        .buffer(false)
-        .end((err, res) => {
-          assert.ifError(err);
-          assert(!res.buffered);
-          assert.equal(res.header['content-length'], Buffer.byteLength(img));
-          done();
-        });
-    }
+ 
const decoder = new StringDecoder('utf8');
+let img = fs.readFileSync(`${__dirname}/fixtures/test.png`);
+img = decoder.write(img);
+request
+  .post(`${base}/echo`)
+  .type('application/x-image')
+  .send(img)
+  .buffer(false)
+  .end((err, res) => {
+    assert.ifError(err);
+    assert(!res.buffered);
+    assert.equal(res.header['content-length'], Buffer.byteLength(img));
+    done();
+  });
should be set to the length of a buffer object
- 
done => {
-      const img = fs.readFileSync(`${__dirname}/fixtures/test.png`);
-      request
-        .post(`${base}/echo`)
-        .type('application/x-image')
-        .send(img)
-        .buffer(true)
-        .end((err, res) => {
-          assert.ifError(err);
-          assert(res.buffered);
-          assert.equal(res.header['content-length'], img.length);
-          done();
-        });
-    }
+ 
const img = fs.readFileSync(`${__dirname}/fixtures/test.png`);
+request
+  .post(`${base}/echo`)
+  .type('application/x-image')
+  .send(img)
+  .buffer(true)
+  .end((err, res) => {
+    assert.ifError(err);
+    assert(res.buffered);
+    assert.equal(res.header['content-length'], img.length);
+    done();
+  });
@@ -3255,99 +2899,91 @@

content-length

req.buffer['someMimeType']

should respect that agent.buffer(true) takes precedent
- 
done => {
-    const agent = request.agent();
-    agent.buffer(true);
-    const type = 'application/somerandomtype';
-    const send = 'somerandomtext';
-    request.buffer[type] = false;
-    agent
-      .post(`${base}/echo`)
-      .type(type)
-      .send(send)
-      .end((err, res) => {
-        delete request.buffer[type];
-        assert.ifError(err);
-        assert.equal(res.type, type);
-        assert.equal(send, res.text);
-        assert(res.buffered);
-        done();
-      });
-  }
+ 
const agent = request.agent();
+agent.buffer(true);
+const type = 'application/somerandomtype';
+const send = 'somerandomtext';
+request.buffer[type] = false;
+agent
+  .post(`${base}/echo`)
+  .type(type)
+  .send(send)
+  .end((err, res) => {
+    delete request.buffer[type];
+    assert.ifError(err);
+    assert.equal(res.type, type);
+    assert.equal(send, res.text);
+    assert(res.buffered);
+    done();
+  });
should respect that agent.buffer(false) takes precedent
- 
done => {
-    const agent = request.agent();
-    agent.buffer(false);
-    const type = 'application/barrr';
-    const send = 'some random text2';
-    request.buffer[type] = true;
-    agent
-      .post(`${base}/echo`)
-      .type(type)
-      .send(send)
-      .end((err, res) => {
-        delete request.buffer[type];
-        assert.ifError(err);
-        assert.equal(null, res.text);
-        assert.equal(res.type, type);
-        assert(!res.buffered);
-        res.body.should.eql({});
-        let buf = '';
-        res.setEncoding('utf8');
-        res.on('data', chunk => {
-          buf += chunk;
-        });
-        res.on('end', () => {
-          buf.should.equal(send);
-          done();
-        });
-      });
-  }
+ 
const agent = request.agent();
+agent.buffer(false);
+const type = 'application/barrr';
+const send = 'some random text2';
+request.buffer[type] = true;
+agent
+  .post(`${base}/echo`)
+  .type(type)
+  .send(send)
+  .end((err, res) => {
+    delete request.buffer[type];
+    assert.ifError(err);
+    assert.equal(null, res.text);
+    assert.equal(res.type, type);
+    assert(!res.buffered);
+    res.body.should.eql({});
+    let buf = '';
+    res.setEncoding('utf8');
+    res.on('data', (chunk) => {
+      buf += chunk;
+    });
+    res.on('end', () => {
+      buf.should.equal(send);
+      done();
+    });
+  });
should disable buffering for that mimetype when false
- 
done => {
-    const type = 'application/bar';
-    const send = 'some random text';
-    request.buffer[type] = false;
-    request
-      .post(`${base}/echo`)
-      .type(type)
-      .send(send)
-      .end((err, res) => {
-        delete request.buffer[type];
-        assert.ifError(err);
-        assert.equal(null, res.text);
-        assert.equal(res.type, type);
-        assert(!res.buffered);
-        res.body.should.eql({});
-        let buf = '';
-        res.setEncoding('utf8');
-        res.on('data', chunk => {
-          buf += chunk;
-        });
-        res.on('end', () => {
-          buf.should.equal(send);
-          done();
-        });
-      });
-  }
+ 
const type = 'application/bar';
+const send = 'some random text';
+request.buffer[type] = false;
+request
+  .post(`${base}/echo`)
+  .type(type)
+  .send(send)
+  .end((err, res) => {
+    delete request.buffer[type];
+    assert.ifError(err);
+    assert.equal(null, res.text);
+    assert.equal(res.type, type);
+    assert(!res.buffered);
+    res.body.should.eql({});
+    let buf = '';
+    res.setEncoding('utf8');
+    res.on('data', (chunk) => {
+      buf += chunk;
+    });
+    res.on('end', () => {
+      buf.should.equal(send);
+      done();
+    });
+  });
should enable buffering for that mimetype when true
- 
done => {
-    const type = 'application/baz';
-    const send = 'woooo';
-    request.buffer[type] = true;
-    request
-      .post(`${base}/echo`)
-      .type(type)
-      .send(send)
-      .end((err, res) => {
-        delete request.buffer[type];
-        assert.ifError(err);
-        assert.equal(res.type, type);
-        assert.equal(send, res.text);
-        assert(res.buffered);
-        done();
-      });
-  }
+ 
const type = 'application/baz';
+const send = 'woooo';
+request.buffer[type] = true;
+request
+  .post(`${base}/echo`)
+  .type(type)
+  .send(send)
+  .end((err, res) => {
+    delete request.buffer[type];
+    assert.ifError(err);
+    assert.equal(res.type, type);
+    assert.equal(send, res.text);
+    assert(res.buffered);
+    done();
+  });
should fallback to default handling for that mimetype when undefined
const type = 'application/bazzz';
 const send = 'woooooo';
@@ -3355,7 +2991,7 @@ 
req.buffer['someMimeType']

   .post(`${base}/echo`)
   .type(type)
   .send(send)
-  .then(res => {
+  .then((res) => {
     assert.equal(res.type, type);
     assert.equal(send, res.body.toString());
     assert(res.buffered);
@@ -3392,127 +3028,109 @@ 
flags

           
with 4xx response

           

             
should set res.error and res.clientError

-            
done => {
-      request.get(`${base}/notfound`).end((err, res) => {
-        assert(err);
-        assert(!res.ok, 'response should not be ok');
-        assert(res.error, 'response should be an error');
-        assert(res.clientError, 'response should be a client error');
-        assert(!res.serverError, 'response should not be a server error');
-        done();
-      });
-    }

+            
request.get(`${base}/notfound`).end((err, res) => {
+  assert(err);
+  assert(!res.ok, 'response should not be ok');
+  assert(res.error, 'response should be an error');
+  assert(res.clientError, 'response should be a client error');
+  assert(!res.serverError, 'response should not be a server error');
+  done();
+});

           

         
         

           
with 5xx response

           

             
should set res.error and res.serverError

-            
done => {
-      request.get(`${base}/error`).end((err, res) => {
-        assert(err);
-        assert(!res.ok, 'response should not be ok');
-        assert(!res.notFound, 'response should not be notFound');
-        assert(res.error, 'response should be an error');
-        assert(!res.clientError, 'response should not be a client error');
-        assert(res.serverError, 'response should be a server error');
-        done();
-      });
-    }

+            
request.get(`${base}/error`).end((err, res) => {
+  assert(err);
+  assert(!res.ok, 'response should not be ok');
+  assert(!res.notFound, 'response should not be notFound');
+  assert(res.error, 'response should be an error');
+  assert(!res.clientError, 'response should not be a client error');
+  assert(res.serverError, 'response should be a server error');
+  done();
+});

           

         

         

           
with 404 Not Found

           

             
should res.notFound

-            
done => {
-      request.get(`${base}/notfound`).end((err, res) => {
-        assert(err);
-        assert(res.notFound, 'response should be .notFound');
-        done();
-      });
-    }

+            
request.get(`${base}/notfound`).end((err, res) => {
+  assert(err);
+  assert(res.notFound, 'response should be .notFound');
+  done();
+});

           

         

         

           
with 400 Bad Request

           

             
should set req.badRequest

-            
done => {
-      request.get(`${base}/bad-request`).end((err, res) => {
-        assert(err);
-        assert(res.badRequest, 'response should be .badRequest');
-        done();
-      });
-    }

+            
request.get(`${base}/bad-request`).end((err, res) => {
+  assert(err);
+  assert(res.badRequest, 'response should be .badRequest');
+  done();
+});

           

         

         

           
with 401 Bad Request

           

             
should set res.unauthorized

-            
done => {
-      request.get(`${base}/unauthorized`).end((err, res) => {
-        assert(err);
-        assert(res.unauthorized, 'response should be .unauthorized');
-        done();
-      });
-    }

+            
request.get(`${base}/unauthorized`).end((err, res) => {
+  assert(err);
+  assert(res.unauthorized, 'response should be .unauthorized');
+  done();
+});

           

         

         

           
with 406 Not Acceptable

           

             
should set res.notAcceptable

-            
done => {
-      request.get(`${base}/not-acceptable`).end((err, res) => {
-        assert(err);
-        assert(res.notAcceptable, 'response should be .notAcceptable');
-        done();
-      });
-    }

+            
request.get(`${base}/not-acceptable`).end((err, res) => {
+  assert(err);
+  assert(res.notAcceptable, 'response should be .notAcceptable');
+  done();
+});

           

         

         

           
with 204 No Content

           

             
should set res.noContent

-            
done => {
-      request.get(`${base}/no-content`).end((err, res) => {
-        assert(!err);
-        assert(res.noContent, 'response should be .noContent');
-        done();
-      });
-    }

+            
request.get(`${base}/no-content`).end((err, res) => {
+  assert(!err);
+  assert(res.noContent, 'response should be .noContent');
+  done();
+});

           

         

         

           
with 201 Created

           

             
should set res.created

-            
done => {
-      request.post(`${base}/created`).end((err, res) => {
-        assert(!err);
-        assert(res.created, 'response should be .created');
-        done();
-      });
-    }

+            
request.post(`${base}/created`).end((err, res) => {
+  assert(!err);
+  assert(res.created, 'response should be .created');
+  done();
+});

           

         

         

           
with 422 Unprocessable Entity

           

             
should set res.unprocessableEntity

-            
done => {
-      request.post(`${base}/unprocessable-entity`).end((err, res) => {
-        assert(err);
-        assert(
-          res.unprocessableEntity,
-          'response should be .unprocessableEntity'
-        );
-        done();
-      });
-    }

+            
request.post(`${base}/unprocessable-entity`).end((err, res) => {
+  assert(err);
+  assert(
+    res.unprocessableEntity,
+    'response should be .unprocessableEntity'
+  );
+  done();
+});
@@ -3533,21 +3151,19 @@

Merging objects

req.send(String)

should default to "form"
- 
done => {
-    request
-      .post(`${base}/echo`)
-      .send('user[name]=tj')
-      .send('user[email]=tj@vision-media.ca')
-      .end((err, res) => {
-        res.header['content-type'].should.equal(
-          'application/x-www-form-urlencoded'
-        );
-        res.body.should.eql({
-          user: { name: 'tj', email: 'tj@vision-media.ca' }
-        });
-        done();
-      });
-  }
+ 
request
+  .post(`${base}/echo`)
+  .send('user[name]=tj')
+  .send('user[email]=tj@vision-media.ca')
+  .end((err, res) => {
+    res.header['content-type'].should.equal(
+      'application/x-www-form-urlencoded'
+    );
+    res.body.should.eql({
+      user: { name: 'tj', email: 'tj@vision-media.ca' }
+    });
+    done();
+  });
@@ -3557,13 +3173,11 @@

res.body

application/x-www-form-urlencoded

should parse the body
- 
done => {
-      request.get(`${base}/form-data`).end((err, res) => {
-        res.text.should.equal('pet[name]=manny');
-        res.body.should.eql({ pet: { name: 'manny' } });
-        done();
-      });
-    }
+ 
request.get(`${base}/form-data`).end((err, res) => {
+  res.text.should.equal('pet[name]=manny');
+  res.body.should.eql({ pet: { name: 'manny' } });
+  done();
+});
@@ -3578,17 +3192,15 @@

certificate authority

request

should give a good response
- 
done => {
-        request
-          .get(testEndpoint)
-          .ca(ca)
-          .end((err, res) => {
-            assert.ifError(err);
-            assert(res.ok);
-            assert.strictEqual('Safe and secure!', res.text);
-            done();
-          });
-      }
+ 
request
+  .get(testEndpoint)
+  .ca(ca)
+  .end((err, res) => {
+    assert.ifError(err);
+    assert(res.ok);
+    assert.strictEqual('Safe and secure!', res.text);
+    done();
+  });
should reject unauthorized response
return request
   .get(testEndpoint)
@@ -3599,6 +3211,13 @@ 
request

     },
     () => {}
   );
+
should not reject unauthorized response
+ 
return request
+  .get(testEndpoint)
+  .disableTLSCerts()
+  .then(({ status }) => {
+    assert.strictEqual(status, 200);
+  });
should trust localhost unauthorized response
return request.get(testEndpoint).trustLocalhost(true);
should trust overriden localhost unauthorized response
@@ -3612,20 +3231,18 @@

request

.agent

should be able to make multiple requests without redefining the certificate
- 
done => {
-        const agent = request.agent({ ca });
-        agent.get(testEndpoint).end((err, res) => {
-          assert.ifError(err);
-          assert(res.ok);
-          assert.strictEqual('Safe and secure!', res.text);
-          agent.get(url.parse(testEndpoint)).end((err, res) => {
-            assert.ifError(err);
-            assert(res.ok);
-            assert.strictEqual('Safe and secure!', res.text);
-            done();
-          });
-        });
-      }
+ 
const agent = request.agent({ ca });
+agent.get(testEndpoint).end((err, res) => {
+  assert.ifError(err);
+  assert(res.ok);
+  assert.strictEqual('Safe and secure!', res.text);
+  agent.get(url.parse(testEndpoint)).end((err, res) => {
+    assert.ifError(err);
+    assert(res.ok);
+    assert.strictEqual('Safe and secure!', res.text);
+    done();
+  });
+});
@@ -3654,48 +3271,42 @@

res.body

image/png

should parse the body
- 
done => {
-      request.get(`${base}/image`).end((err, res) => {
-        res.type.should.equal('image/png');
-        Buffer.isBuffer(res.body).should.be.true();
-        (res.body.length - img.length).should.equal(0);
-        done();
-      });
-    }
+ 
request.get(`${base}/image`).end((err, res) => {
+  res.type.should.equal('image/png');
+  Buffer.isBuffer(res.body).should.be.true();
+  (res.body.length - img.length).should.equal(0);
+  done();
+});

application/octet-stream

should parse the body
- 
done => {
-      request
-        .get(`${base}/image-as-octets`)
-        .buffer(true) // that's tech debt :(
-        .end((err, res) => {
-          res.type.should.equal('application/octet-stream');
-          Buffer.isBuffer(res.body).should.be.true();
-          (res.body.length - img.length).should.equal(0);
-          done();
-        });
-    }
+ 
request
+  .get(`${base}/image-as-octets`)
+  .buffer(true) // that's tech debt :(
+  .end((err, res) => {
+    res.type.should.equal('application/octet-stream');
+    Buffer.isBuffer(res.body).should.be.true();
+    (res.body.length - img.length).should.equal(0);
+    done();
+  });

application/octet-stream

should parse the body (using responseType)
- 
done => {
-      request
-        .get(`${base}/image-as-octets`)
-        .responseType('blob')
-        .end((err, res) => {
-          res.type.should.equal('application/octet-stream');
-          Buffer.isBuffer(res.body).should.be.true();
-          (res.body.length - img.length).should.equal(0);
-          done();
-        });
-    }
+ 
request
+  .get(`${base}/image-as-octets`)
+  .responseType('blob')
+  .end((err, res) => {
+    res.type.should.equal('application/octet-stream');
+    Buffer.isBuffer(res.body).should.be.true();
+    (res.body.length - img.length).should.equal(0);
+    done();
+  });
@@ -3704,65 +3315,53 @@

application/octet-stream

zlib

should deflate the content
- 
done => {
-    request.get(base).end((err, res) => {
-      res.should.have.status(200);
-      res.text.should.equal(subject);
-      res.headers['content-length'].should.be.below(subject.length);
-      done();
-    });
-  }
+ 
request.get(base).end((err, res) => {
+  res.should.have.status(200);
+  res.text.should.equal(subject);
+  res.headers['content-length'].should.be.below(subject.length);
+  done();
+});
should protect from zip bombs
- 
done => {
-    request
-      .get(base)
-      .buffer(true)
-      .maxResponseSize(1)
-      .end((err, res) => {
-        try {
-          assert.equal('Maximum response size reached', err && err.message);
-          done();
-        } catch (err2) {
-          done(err2);
-        }
-      });
-  }
-
should ignore trailing junk
- 
done => {
-    request.get(`${base}/junk`).end((err, res) => {
-      res.should.have.status(200);
-      res.text.should.equal(subject);
+        
request
+  .get(base)
+  .buffer(true)
+  .maxResponseSize(1)
+  .end((err, res) => {
+    try {
+      assert.equal('Maximum response size reached', err && err.message);
       done();
-    });
-  }

+    } catch (err_) {
+      done(err_);
+    }
+  });
+
should ignore trailing junk
+ 
request.get(`${base}/junk`).end((err, res) => {
+  res.should.have.status(200);
+  res.text.should.equal(subject);
+  done();
+});
should ignore missing data
- 
done => {
-    request.get(`${base}/chopped`).end((err, res) => {
-      assert.equal(undefined, err);
-      res.should.have.status(200);
-      res.text.should.startWith(subject);
-      done();
-    });
-  }
+ 
request.get(`${base}/chopped`).end((err, res) => {
+  assert.equal(undefined, err);
+  res.should.have.status(200);
+  res.text.should.startWith(subject);
+  done();
+});
should handle corrupted responses
- 
done => {
-    request.get(`${base}/corrupt`).end((err, res) => {
-      assert(err, 'missing error');
-      assert(!res, 'response should not be defined');
-      done();
-    });
-  }
+ 
request.get(`${base}/corrupt`).end((err, res) => {
+  assert(err, 'missing error');
+  assert(!res, 'response should not be defined');
+  done();
+});
should handle no content with gzip header
- 
done => {
-    request.get(`${base}/nocontent`).end((err, res) => {
-      assert.ifError(err);
-      assert(res);
-      res.should.have.status(204);
-      res.text.should.equal('');
-      res.headers.should.not.have.property('content-length');
-      done();
-    });
-  }
+ 
request.get(`${base}/nocontent`).end((err, res) => {
+  assert.ifError(err);
+  assert(res);
+  res.should.have.status(204);
+  res.text.should.equal('');
+  res.headers.should.not.have.property('content-length');
+  done();
+});

without encoding set

@@ -3770,23 +3369,21 @@

without encoding set

return request
   .get(`${base}/binary`)
   .buffer(true)
-  .then(res => {
+  .then((res) => {
     res.should.have.status(200);
     assert(res.headers['content-length']);
     assert(res.body.byteLength);
     assert.equal(subject, res.body.toString());
   });
should emit buffers
- 
done => {
-      request.get(`${base}/binary`).end((err, res) => {
-        res.should.have.status(200);
-        res.headers['content-length'].should.be.below(subject.length);
-        res.on('data', chunk => {
-          chunk.should.have.length(subject.length);
-        });
-        res.on('end', done);
-      });
-    }
+ 
request.get(`${base}/binary`).end((err, res) => {
+  res.should.have.status(200);
+  res.headers['content-length'].should.be.below(subject.length);
+  res.on('data', (chunk) => {
+    chunk.should.have.length(subject.length);
+  });
+  res.on('end', done);
+});
@@ -3802,7 +3399,7 @@

#field(name, value)

req.field('user[name]', 'tobi'); req.field('user[age]', '2'); req.field('user[species]', 'ferret'); -return req.then(res => { +return req.then((res) => { res.body['user[name]'].should.equal('tobi'); res.body['user[age]'].should.equal('2'); res.body['user[species]'].should.equal('ferret'); @@ -3812,7 +3409,7 @@

#field(name, value)

req.field('name', 'Tobi'); req.attach('document', 'test/node/fixtures/user.html'); req.field('species', 'ferret'); -return req.then(res => { +return req.then((res) => { res.body.name.should.equal('Tobi'); res.body.species.should.equal('ferret'); const html = res.files.document; @@ -3830,7 +3427,7 @@

#attach(name, path)

req.attach('one', 'test/node/fixtures/user.html'); req.attach('two', 'test/node/fixtures/user.json'); req.attach('three', 'test/node/fixtures/user.txt'); -return req.then(res => { +return req.then((res) => { const html = res.files.one; const json = res.files.two; const text = res.files.three; @@ -3848,49 +3445,45 @@

#attach(name, path)

when a file does not exist

should fail the request with an error
- 
done => {
-        const req = request.post(`${base}/echo`);
-        req.attach('name', 'foo');
-        req.attach('name2', 'bar');
-        req.attach('name3', 'baz');
-        req.end((err, res) => {
-          assert.ok(Boolean(err), 'Request should have failed.');
-          err.code.should.equal('ENOENT');
-          err.message.should.containEql('ENOENT');
-          err.path.should.equal('foo');
-          done();
-        });
-      }
+ 
const req = request.post(`${base}/echo`);
+req.attach('name', 'foo');
+req.attach('name2', 'bar');
+req.attach('name3', 'baz');
+req.end((err, res) => {
+  assert.ok(Boolean(err), 'Request should have failed.');
+  err.code.should.equal('ENOENT');
+  err.message.should.containEql('ENOENT');
+  err.path.should.equal('foo');
+  done();
+});
promise should fail
return request
   .post(`${base}/echo`)
   .field({ a: 1, b: 2 })
   .attach('c', 'does-not-exist.txt')
   .then(
-    res => assert.fail('It should not allow this'),
-    err => {
+    (res) => assert.fail('It should not allow this'),
+    (err) => {
       err.code.should.equal('ENOENT');
       err.path.should.equal('does-not-exist.txt');
     }
   );
should report ECONNREFUSED via the callback
- 
done => {
-        request
-          .post('http://127.0.0.1:1') // nobody is listening there
-          .attach('name', 'file-does-not-exist')
-          .end((err, res) => {
-            assert.ok(Boolean(err), 'Request should have failed');
-            err.code.should.equal('ECONNREFUSED');
-            done();
-          });
-      }
+ 
request
+  .post('http://127.0.0.1:1') // nobody is listening there
+  .attach('name', 'file-does-not-exist')
+  .end((err, res) => {
+    assert.ok(Boolean(err), 'Request should have failed');
+    err.code.should.equal('ECONNREFUSED');
+    done();
+  });
should report ECONNREFUSED via Promise
return request
   .post('http://127.0.0.1:1') // nobody is listening there
   .attach('name', 'file-does-not-exist')
   .then(
-    res => assert.fail('Request should have failed'),
-    err => err.code.should.equal('ECONNREFUSED')
+    (res) => assert.fail('Request should have failed'),
+    (err) => err.code.should.equal('ECONNREFUSED')
   );
@@ -3903,88 +3496,80 @@

#attach(name, path, filename)

request
         .post(`${base}/echo`)
         .attach('document', 'test/node/fixtures/user.html', 'doc.html')
-        .then(res => {
+        .then((res) => {
           const html = res.files.document;
           html.name.should.equal('doc.html');
           html.type.should.equal('text/html');
           read(html.path).should.equal('<h1>name</h1>');
         })
should fire progress event
- 
done => {
-      let loaded = 0;
-      let total = 0;
-      let uploadEventWasFired = false;
-      request
-        .post(`${base}/echo`)
-        .attach('document', 'test/node/fixtures/user.html')
-        .on('progress', event => {
-          total = event.total;
-          loaded = event.loaded;
-          if (event.direction === 'upload') {
-            uploadEventWasFired = true;
-          }
-        })
-        .end((err, res) => {
-          if (err) return done(err);
-          const html = res.files.document;
-          html.name.should.equal('user.html');
-          html.type.should.equal('text/html');
-          read(html.path).should.equal('<h1>name</h1>');
-          total.should.equal(223);
-          loaded.should.equal(223);
-          uploadEventWasFired.should.equal(true);
-          done();
-        });
-    }
+ 
let loaded = 0;
+let total = 0;
+let uploadEventWasFired = false;
+request
+  .post(`${base}/echo`)
+  .attach('document', 'test/node/fixtures/user.html')
+  .on('progress', (event) => {
+    total = event.total;
+    loaded = event.loaded;
+    if (event.direction === 'upload') {
+      uploadEventWasFired = true;
+    }
+  })
+  .end((err, res) => {
+    if (err) return done(err);
+    const html = res.files.document;
+    html.name.should.equal('user.html');
+    html.type.should.equal('text/html');
+    read(html.path).should.equal('<h1>name</h1>');
+    total.should.equal(223);
+    loaded.should.equal(223);
+    uploadEventWasFired.should.equal(true);
+    done();
+  });
filesystem errors should be caught
- 
done => {
-      request
-        .post(`${base}/echo`)
-        .attach('filedata', 'test/node/fixtures/non-existent-file.ext')
-        .end((err, res) => {
-          assert.ok(Boolean(err), 'Request should have failed.');
-          err.code.should.equal('ENOENT');
-          err.path.should.equal('test/node/fixtures/non-existent-file.ext');
-          done();
-        });
-    }
+ 
request
+  .post(`${base}/echo`)
+  .attach('filedata', 'test/node/fixtures/non-existent-file.ext')
+  .end((err, res) => {
+    assert.ok(Boolean(err), 'Request should have failed.');
+    err.code.should.equal('ENOENT');
+    err.path.should.equal('test/node/fixtures/non-existent-file.ext');
+    done();
+  });

#field(name, val)

should set a multipart field value
- 
done => {
-      request
-        .post(`${base}/echo`)
-        .field('first-name', 'foo')
-        .field('last-name', 'bar')
-        .end((err, res) => {
-          if (err) done(err);
-          res.should.be.ok();
-          res.body['first-name'].should.equal('foo');
-          res.body['last-name'].should.equal('bar');
-          done();
-        });
-    }
+ 
request
+  .post(`${base}/echo`)
+  .field('first-name', 'foo')
+  .field('last-name', 'bar')
+  .end((err, res) => {
+    if (err) done(err);
+    res.should.be.ok();
+    res.body['first-name'].should.equal('foo');
+    res.body['last-name'].should.equal('bar');
+    done();
+  });

#field(object)

should set multiple multipart fields
- 
done => {
-      request
-        .post(`${base}/echo`)
-        .field({ 'first-name': 'foo', 'last-name': 'bar' })
-        .end((err, res) => {
-          if (err) done(err);
-          res.should.be.ok();
-          res.body['first-name'].should.equal('foo');
-          res.body['last-name'].should.equal('bar');
-          done();
-        });
-    }
+ 
request
+  .post(`${base}/echo`)
+  .field({ 'first-name': 'foo', 'last-name': 'bar' })
+  .end((err, res) => {
+    if (err) done(err);
+    res.should.be.ok();
+    res.body['first-name'].should.equal('foo');
+    res.body['last-name'].should.equal('bar');
+    done();
+  });
@@ -4006,25 +3591,21 @@

request

not modified

should start with 200
- 
done => {
-      request.get(`${base}/if-mod`).end((err, res) => {
-        res.should.have.status(200);
-        res.text.should.match(/^\d+$/);
-        ts = Number(res.text);
-        done();
-      });
-    }
+ 
request.get(`${base}/if-mod`).end((err, res) => {
+  res.should.have.status(200);
+  res.text.should.match(/^\d+$/);
+  ts = Number(res.text);
+  done();
+});
should then be 304
- 
done => {
-      request
-        .get(`${base}/if-mod`)
-        .set('If-Modified-Since', new Date(ts).toUTCString())
-        .end((err, res) => {
-          res.should.have.status(304);
-          // res.text.should.be.empty
-          done();
-        });
-    }
+ 
request
+  .get(`${base}/if-mod`)
+  .set('If-Modified-Since', new Date(ts).toUTCString())
+  .end((err, res) => {
+    res.should.have.status(304);
+    // res.text.should.be.empty
+    done();
+  });
@@ -4033,17 +3614,15 @@

not modified

req.parse(fn)

should take precedence over default parsers
- 
done => {
-    request
-      .get(`${base}/manny`)
-      .parse(request.parse['application/json'])
-      .end((err, res) => {
-        assert(res.ok);
-        assert.equal('{"name":"manny"}', res.text);
-        assert.equal('manny', res.body.name);
-        done();
-      });
-  }
+ 
request
+  .get(`${base}/manny`)
+  .parse(request.parse['application/json'])
+  .end((err, res) => {
+    assert(res.ok);
+    assert.equal('{"name":"manny"}', res.text);
+    assert.equal('manny', res.body.name);
+    done();
+  });
should be the only parser
request
       .get(`${base}/image`)
@@ -4051,200 +3630,211 @@ 
req.parse(fn)

       .parse((res, fn) => {
         res.on('data', () => {});
       })
-      .then(res => {
+      .then((res) => {
         assert(res.ok);
         assert.strictEqual(res.text, undefined);
         res.body.should.eql({});
       })
should emit error if parser throws
- 
done => {
-    request
-      .get(`${base}/manny`)
-      .parse(() => {
-        throw new Error('I am broken');
-      })
-      .on('error', err => {
-        err.message.should.equal('I am broken');
-        done();
-      })
-      .end();
-  }
+ 
request
+  .get(`${base}/manny`)
+  .parse(() => {
+    throw new Error('I am broken');
+  })
+  .on('error', (err) => {
+    err.message.should.equal('I am broken');
+    done();
+  })
+  .end();
should emit error if parser returns an error
- 
done => {
-    request
-      .get(`${base}/manny`)
-      .parse((res, fn) => {
-        fn(new Error('I am broken'));
-      })
-      .on('error', err => {
-        err.message.should.equal('I am broken');
-        done();
-      })
-      .end();
-  }
+ 
request
+  .get(`${base}/manny`)
+  .parse((res, fn) => {
+    fn(new Error('I am broken'));
+  })
+  .on('error', (err) => {
+    err.message.should.equal('I am broken');
+    done();
+  })
+  .end();
should not emit error on chunked json
- 
done => {
-      request.get(`${base}/chunked-json`).end(err => {
-        assert.ifError(err);
-        done();
-      });
-    }
+ 
request.get(`${base}/chunked-json`).end((err) => {
+  assert.ifError(err);
+  done();
+});
should not emit error on aborted chunked json
- 
done => {
-      const req = request.get(`${base}/chunked-json`);
-      req.end(err => {
-        assert.ifError(err);
-        done();
-      });
-      setTimeout(() => {
-        req.abort();
-      }, 50);
-    }
+ 
const req = request.get(`${base}/chunked-json`);
+req.end((err) => {
+  assert.ifError(err);
+  done();
+});
+setTimeout(() => {
+  req.abort();
+}, 50);

pipe on redirect

should follow Location
- 
done => {
-    const stream = fs.createWriteStream(destPath);
-    const redirects = [];
-    const req = request
-      .get(base)
-      .on('redirect', res => {
-        redirects.push(res.headers.location);
-      })
-      .connect({
-        inapplicable: 'should be ignored'
-      });
-    stream.on('finish', () => {
-      redirects.should.eql(['/movies', '/movies/all', '/movies/all/0']);
-      fs.readFileSync(destPath, 'utf8').should.eql('first movie page');
-      done();
-    });
-    req.pipe(stream);
-  }
+ 
const stream = fs.createWriteStream(destPath);
+const redirects = [];
+const req = request
+  .get(base)
+  .on('redirect', (res) => {
+    redirects.push(res.headers.location);
+  })
+  .connect({
+    inapplicable: 'should be ignored'
+  });
+stream.on('finish', () => {
+  redirects.should.eql(['/movies', '/movies/all', '/movies/all/0']);
+  fs.readFileSync(destPath, 'utf8').should.eql('first movie page');
+  done();
+});
+req.pipe(stream);

request pipe

should act as a writable stream
- 
done => {
-    const req = request.post(base);
-    const stream = fs.createReadStream('test/node/fixtures/user.json');
-    req.type('json');
-    req.on('response', res => {
-      res.body.should.eql({ name: 'tobi' });
-      done();
-    });
-    stream.pipe(req);
-  }
+ 
const req = request.post(base);
+const stream = fs.createReadStream('test/node/fixtures/user.json');
+req.type('json');
+req.on('response', (res) => {
+  res.body.should.eql({ name: 'tobi' });
+  done();
+});
+stream.pipe(req);
end() stops piping
- 
done => {
-    const stream = fs.createWriteStream(destPath);
-    request.get(base).end((err, res) => {
-      try {
-        res.pipe(stream);
-        return done(new Error('Did not prevent nonsense pipe'));
-      } catch (err2) {
-        /* expected error */
-      }
-      done();
-    });
-  }
+ 
const stream = fs.createWriteStream(destPath);
+request.get(base).end((err, res) => {
+  try {
+    res.pipe(stream);
+    return done(new Error('Did not prevent nonsense pipe'));
+  } catch {
+    /* expected error */
+  }
+  done();
+});
should act as a readable stream
- 
done => {
-    const stream = fs.createWriteStream(destPath);
-    let responseCalled = false;
-    const req = request.get(base);
-    req.type('json');
-    req.on('response', res => {
-      res.status.should.eql(200);
-      responseCalled = true;
-    });
-    stream.on('finish', () => {
-      JSON.parse(fs.readFileSync(destPath, 'utf8')).should.eql({
-        name: 'tobi'
-      });
-      responseCalled.should.be.true();
-      done();
-    });
-    req.pipe(stream);
-  }
+ 
const stream = fs.createWriteStream(destPath);
+let responseCalled = false;
+const req = request.get(base);
+req.type('json');
+req.on('response', (res) => {
+  res.status.should.eql(200);
+  responseCalled = true;
+});
+stream.on('finish', () => {
+  JSON.parse(fs.readFileSync(destPath, 'utf8')).should.eql({
+    name: 'tobi'
+  });
+  responseCalled.should.be.true();
+  done();
+});
+req.pipe(stream);
+
should follow redirects
+ 
const stream = fs.createWriteStream(destPath);
+let responseCalled = false;
+const req = request.get(base + '/redirect');
+req.type('json');
+req.on('response', (res) => {
+  res.status.should.eql(200);
+  responseCalled = true;
+});
+stream.on('finish', () => {
+  JSON.parse(fs.readFileSync(destPath, 'utf8')).should.eql({
+    name: 'tobi'
+  });
+  responseCalled.should.be.true();
+  done();
+});
+req.pipe(stream);
+
should not throw on bad redirects
+ 
const stream = fs.createWriteStream(destPath);
+let responseCalled = false;
+let errorCalled = false;
+const req = request.get(base + '/badRedirectNoLocation');
+req.type('json');
+req.on('response', (res) => {
+  responseCalled = true;
+});
+req.on('error', (err) => {
+  err.message.should.eql('No location header for redirect');
+  errorCalled = true;
+  stream.end();
+});
+stream.on('finish', () => {
+  responseCalled.should.be.false();
+  errorCalled.should.be.true();
+  done();
+});
+req.pipe(stream);

req.query(String)

should support passing in a string
- 
done => {
-    request
-      .del(base)
-      .query('name=t%F6bi')
-      .end((err, res) => {
-        res.body.should.eql({ name: 't%F6bi' });
-        done();
-      });
-  }
+ 
request
+  .del(base)
+  .query('name=t%F6bi')
+  .end((err, res) => {
+    res.body.should.eql({ name: 't%F6bi' });
+    done();
+  });
should work with url query-string and string for query
- 
done => {
-    request
-      .del(`${base}/?name=tobi`)
-      .query('age=2%20')
-      .end((err, res) => {
-        res.body.should.eql({ name: 'tobi', age: '2 ' });
-        done();
-      });
-  }
+ 
request
+  .del(`${base}/?name=tobi`)
+  .query('age=2%20')
+  .end((err, res) => {
+    res.body.should.eql({ name: 'tobi', age: '2 ' });
+    done();
+  });
should support compound elements in a string
- 
done => {
-    request
-      .del(base)
-      .query('name=t%F6bi&age=2')
-      .end((err, res) => {
-        res.body.should.eql({ name: 't%F6bi', age: '2' });
-        done();
-      });
-  }
+ 
request
+  .del(base)
+  .query('name=t%F6bi&age=2')
+  .end((err, res) => {
+    res.body.should.eql({ name: 't%F6bi', age: '2' });
+    done();
+  });
should work when called multiple times with a string
- 
done => {
-    request
-      .del(base)
-      .query('name=t%F6bi')
-      .query('age=2%F6')
-      .end((err, res) => {
-        res.body.should.eql({ name: 't%F6bi', age: '2%F6' });
-        done();
-      });
-  }
+ 
request
+  .del(base)
+  .query('name=t%F6bi')
+  .query('age=2%F6')
+  .end((err, res) => {
+    res.body.should.eql({ name: 't%F6bi', age: '2%F6' });
+    done();
+  });
should work with normal `query` object and query string
- 
done => {
-    request
-      .del(base)
-      .query('name=t%F6bi')
-      .query({ age: '2' })
-      .end((err, res) => {
-        res.body.should.eql({ name: 't%F6bi', age: '2' });
-        done();
-      });
-  }
+ 
request
+  .del(base)
+  .query('name=t%F6bi')
+  .query({ age: '2' })
+  .end((err, res) => {
+    res.body.should.eql({ name: 't%F6bi', age: '2' });
+    done();
+  });
should not encode raw backticks, but leave encoded ones as is
return Promise.all([
   request
     .get(`${base}/raw-query`)
     .query('name=`t%60bi`&age`=2')
-    .then(res => {
+    .then((res) => {
       res.text.should.eql('name=`t%60bi`&age`=2');
     }),
-  request.get(base + '/raw-query?`age%60`=2%60`').then(res => {
+  request.get(base + '/raw-query?`age%60`=2%60`').then((res) => {
     res.text.should.eql('`age%60`=2%60`');
   }),
   request
     .get(`${base}/raw-query`)
     .query('name=`t%60bi`')
     .query('age`=2')
-    .then(res => {
+    .then((res) => {
       res.text.should.eql('name=`t%60bi`&age`=2');
     })
 ]);
@@ -4254,91 +3844,75 @@

req.query(String)

req.query(Object)

should construct the query-string
- 
done => {
-    request
-      .del(base)
-      .query({ name: 'tobi' })
-      .query({ order: 'asc' })
-      .query({ limit: ['1', '2'] })
-      .end((err, res) => {
-        res.body.should.eql({ name: 'tobi', order: 'asc', limit: ['1', '2'] });
-        done();
-      });
-  }
+ 
request
+  .del(base)
+  .query({ name: 'tobi' })
+  .query({ order: 'asc' })
+  .query({ limit: ['1', '2'] })
+  .end((err, res) => {
+    res.body.should.eql({ name: 'tobi', order: 'asc', limit: ['1', '2'] });
+    done();
+  });
should encode raw backticks
- 
done => {
-    request
-      .get(`${base}/raw-query`)
-      .query({ name: '`tobi`' })
-      .query({ 'orde%60r': null })
-      .query({ '`limit`': ['%602`'] })
-      .end((err, res) => {
-        res.text.should.eql('name=%60tobi%60&orde%2560r&%60limit%60=%25602%60');
-        done();
-      });
-  }
+ 
request
+  .get(`${base}/raw-query`)
+  .query({ name: '`tobi`' })
+  .query({ 'orde%60r': null })
+  .query({ '`limit`': ['%602`'] })
+  .end((err, res) => {
+    res.text.should.eql('name=%60tobi%60&orde%2560r&%60limit%60=%25602%60');
+    done();
+  });
should not error on dates
- 
done => {
-    const date = new Date(0);
-    request
-      .del(base)
-      .query({ at: date })
-      .end((err, res) => {
-        assert.equal(date.toISOString(), res.body.at);
-        done();
-      });
-  }
+ 
const date = new Date(0);
+request
+  .del(base)
+  .query({ at: date })
+  .end((err, res) => {
+    assert.equal(date.toISOString(), res.body.at);
+    done();
+  });
should work after setting header fields
- 
done => {
-    request
-      .del(base)
-      .set('Foo', 'bar')
-      .set('Bar', 'baz')
-      .query({ name: 'tobi' })
-      .query({ order: 'asc' })
-      .query({ limit: ['1', '2'] })
-      .end((err, res) => {
-        res.body.should.eql({ name: 'tobi', order: 'asc', limit: ['1', '2'] });
-        done();
-      });
-  }
+ 
request
+  .del(base)
+  .set('Foo', 'bar')
+  .set('Bar', 'baz')
+  .query({ name: 'tobi' })
+  .query({ order: 'asc' })
+  .query({ limit: ['1', '2'] })
+  .end((err, res) => {
+    res.body.should.eql({ name: 'tobi', order: 'asc', limit: ['1', '2'] });
+    done();
+  });
should append to the original query-string
- 
done => {
-    request
-      .del(`${base}/?name=tobi`)
-      .query({ order: 'asc' })
-      .end((err, res) => {
-        res.body.should.eql({ name: 'tobi', order: 'asc' });
-        done();
-      });
-  }
+ 
request
+  .del(`${base}/?name=tobi`)
+  .query({ order: 'asc' })
+  .end((err, res) => {
+    res.body.should.eql({ name: 'tobi', order: 'asc' });
+    done();
+  });
should retain the original query-string
- 
done => {
-    request.del(`${base}/?name=tobi`).end((err, res) => {
-      res.body.should.eql({ name: 'tobi' });
-      done();
-    });
-  }
+ 
request.del(`${base}/?name=tobi`).end((err, res) => {
+  res.body.should.eql({ name: 'tobi' });
+  done();
+});
should keep only keys with null querystring values
- 
done => {
-    request
-      .del(`${base}/url`)
-      .query({ nil: null })
-      .end((err, res) => {
-        res.text.should.equal('/url?nil');
-        done();
-      });
-  }
+ 
request
+  .del(`${base}/url`)
+  .query({ nil: null })
+  .end((err, res) => {
+    res.text.should.equal('/url?nil');
+    done();
+  });
query-string should be sent on pipe
- 
done => {
-    const req = request.put(`${base}/?name=tobi`);
-    const stream = fs.createReadStream('test/node/fixtures/user.json');
-    req.on('response', res => {
-      res.body.should.eql({ name: 'tobi' });
-      done();
-    });
-    stream.pipe(req);
-  }
+ 
const req = request.put(`${base}/?name=tobi`);
+const stream = fs.createReadStream('test/node/fixtures/user.json');
+req.on('response', (res) => {
+  res.body.should.eql({ name: 'tobi' });
+  done();
+});
+stream.pipe(req);
@@ -4348,75 +3922,79 @@

request.get

on 301 redirect

should follow Location with a GET request
- 
done => {
-      const req = request.get(`${base}/test-301`).redirects(1);
-      req.end((err, res) => {
-        req.req._headers.host.should.eql(`localhost:${server2.address().port}`);
-        res.status.should.eql(200);
-        res.text.should.eql('GET');
-        done();
-      });
-    }
+ 
const req = request.get(`${base}/test-301`).redirects(1);
+req.end((err, res) => {
+  const headers = req.req.getHeaders
+    ? req.req.getHeaders()
+    : req.req._headers;
+  headers.host.should.eql(`localhost:${server2.address().port}`);
+  res.status.should.eql(200);
+  res.text.should.eql('GET');
+  done();
+});

on 302 redirect

should follow Location with a GET request
- 
done => {
-      const req = request.get(`${base}/test-302`).redirects(1);
-      req.end((err, res) => {
-        req.req._headers.host.should.eql(`localhost:${server2.address().port}`);
-        res.status.should.eql(200);
-        res.text.should.eql('GET');
-        done();
-      });
-    }
+ 
const req = request.get(`${base}/test-302`).redirects(1);
+req.end((err, res) => {
+  const headers = req.req.getHeaders
+    ? req.req.getHeaders()
+    : req.req._headers;
+  res.status.should.eql(200);
+  res.text.should.eql('GET');
+  done();
+});

on 303 redirect

should follow Location with a GET request
- 
done => {
-      const req = request.get(`${base}/test-303`).redirects(1);
-      req.end((err, res) => {
-        req.req._headers.host.should.eql(`localhost:${server2.address().port}`);
-        res.status.should.eql(200);
-        res.text.should.eql('GET');
-        done();
-      });
-    }
+ 
const req = request.get(`${base}/test-303`).redirects(1);
+req.end((err, res) => {
+  const headers = req.req.getHeaders
+    ? req.req.getHeaders()
+    : req.req._headers;
+  headers.host.should.eql(`localhost:${server2.address().port}`);
+  res.status.should.eql(200);
+  res.text.should.eql('GET');
+  done();
+});

on 307 redirect

should follow Location with a GET request
- 
done => {
-      const req = request.get(`${base}/test-307`).redirects(1);
-      req.end((err, res) => {
-        req.req._headers.host.should.eql(`localhost:${server2.address().port}`);
-        res.status.should.eql(200);
-        res.text.should.eql('GET');
-        done();
-      });
-    }
+ 
const req = request.get(`${base}/test-307`).redirects(1);
+req.end((err, res) => {
+  const headers = req.req.getHeaders
+    ? req.req.getHeaders()
+    : req.req._headers;
+  headers.host.should.eql(`localhost:${server2.address().port}`);
+  res.status.should.eql(200);
+  res.text.should.eql('GET');
+  done();
+});

on 308 redirect

should follow Location with a GET request
- 
done => {
-      const req = request.get(`${base}/test-308`).redirects(1);
-      req.end((err, res) => {
-        req.req._headers.host.should.eql(`localhost:${server2.address().port}`);
-        res.status.should.eql(200);
-        res.text.should.eql('GET');
-        done();
-      });
-    }
+ 
const req = request.get(`${base}/test-308`).redirects(1);
+req.end((err, res) => {
+  const headers = req.req.getHeaders
+    ? req.req.getHeaders()
+    : req.req._headers;
+  headers.host.should.eql(`localhost:${server2.address().port}`);
+  res.status.should.eql(200);
+  res.text.should.eql('GET');
+  done();
+});
@@ -4428,75 +4006,80 @@

request.post

on 301 redirect

should follow Location with a GET request
- 
done => {
-      const req = request.post(`${base}/test-301`).redirects(1);
-      req.end((err, res) => {
-        req.req._headers.host.should.eql(`localhost:${server2.address().port}`);
-        res.status.should.eql(200);
-        res.text.should.eql('GET');
-        done();
-      });
-    }
+ 
const req = request.post(`${base}/test-301`).redirects(1);
+req.end((err, res) => {
+  const headers = req.req.getHeaders
+    ? req.req.getHeaders()
+    : req.req._headers;
+  headers.host.should.eql(`localhost:${server2.address().port}`);
+  res.status.should.eql(200);
+  res.text.should.eql('GET');
+  done();
+});

on 302 redirect

should follow Location with a GET request
- 
done => {
-      const req = request.post(`${base}/test-302`).redirects(1);
-      req.end((err, res) => {
-        req.req._headers.host.should.eql(`localhost:${server2.address().port}`);
-        res.status.should.eql(200);
-        res.text.should.eql('GET');
-        done();
-      });
-    }
+ 
const req = request.post(`${base}/test-302`).redirects(1);
+req.end((err, res) => {
+  const headers = req.req.getHeaders
+    ? req.req.getHeaders()
+    : req.req._headers;
+  headers.host.should.eql(`localhost:${server2.address().port}`);
+  res.status.should.eql(200);
+  res.text.should.eql('GET');
+  done();
+});

on 303 redirect

should follow Location with a GET request
- 
done => {
-      const req = request.post(`${base}/test-303`).redirects(1);
-      req.end((err, res) => {
-        req.req._headers.host.should.eql(`localhost:${server2.address().port}`);
-        res.status.should.eql(200);
-        res.text.should.eql('GET');
-        done();
-      });
-    }
+ 
const req = request.post(`${base}/test-303`).redirects(1);
+req.end((err, res) => {
+  const headers = req.req.getHeaders
+    ? req.req.getHeaders()
+    : req.req._headers;
+  headers.host.should.eql(`localhost:${server2.address().port}`);
+  res.status.should.eql(200);
+  res.text.should.eql('GET');
+  done();
+});

on 307 redirect

should follow Location with a POST request
- 
done => {
-      const req = request.post(`${base}/test-307`).redirects(1);
-      req.end((err, res) => {
-        req.req._headers.host.should.eql(`localhost:${server2.address().port}`);
-        res.status.should.eql(200);
-        res.text.should.eql('POST');
-        done();
-      });
-    }
+ 
const req = request.post(`${base}/test-307`).redirects(1);
+req.end((err, res) => {
+  const headers = req.req.getHeaders
+    ? req.req.getHeaders()
+    : req.req._headers;
+  headers.host.should.eql(`localhost:${server2.address().port}`);
+  res.status.should.eql(200);
+  res.text.should.eql('POST');
+  done();
+});

on 308 redirect

should follow Location with a POST request
- 
done => {
-      const req = request.post(`${base}/test-308`).redirects(1);
-      req.end((err, res) => {
-        req.req._headers.host.should.eql(`localhost:${server2.address().port}`);
-        res.status.should.eql(200);
-        res.text.should.eql('POST');
-        done();
-      });
-    }
+ 
const req = request.post(`${base}/test-308`).redirects(1);
+req.end((err, res) => {
+  const headers = req.req.getHeaders
+    ? req.req.getHeaders()
+    : req.req._headers;
+  headers.host.should.eql(`localhost:${server2.address().port}`);
+  res.status.should.eql(200);
+  res.text.should.eql('POST');
+  done();
+});
@@ -4508,80 +4091,72 @@

request

on redirect

should merge cookies if agent is used
- 
done => {
-      request
-        .agent()
-        .get(`${base}/cookie-redirect`)
-        .set('Cookie', 'orig=1; replaced=not')
-        .end((err, res) => {
-          try {
-            assert.ifError(err);
-            assert(/orig=1/.test(res.text), 'orig=1/.test');
-            assert(/replaced=yes/.test(res.text), 'replaced=yes/.test');
-            assert(/from-redir=1/.test(res.text), 'from-redir=1');
-            done();
-          } catch (err2) {
-            done(err2);
-          }
-        });
-    }
+ 
request
+  .agent()
+  .get(`${base}/cookie-redirect`)
+  .set('Cookie', 'orig=1; replaced=not')
+  .end((err, res) => {
+    try {
+      assert.ifError(err);
+      assert(/orig=1/.test(res.text), 'orig=1/.test');
+      assert(/replaced=yes/.test(res.text), 'replaced=yes/.test');
+      assert(/from-redir=1/.test(res.text), 'from-redir=1');
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });
should not merge cookies if agent is not used
- 
done => {
-      request
-        .get(`${base}/cookie-redirect`)
-        .set('Cookie', 'orig=1; replaced=not')
-        .end((err, res) => {
-          try {
-            assert.ifError(err);
-            assert(/orig=1/.test(res.text), '/orig=1');
-            assert(/replaced=not/.test(res.text), '/replaced=not');
-            assert(!/replaced=yes/.test(res.text), '!/replaced=yes');
-            assert(!/from-redir/.test(res.text), '!/from-redir');
-            done();
-          } catch (err2) {
-            done(err2);
-          }
-        });
-    }
+ 
request
+  .get(`${base}/cookie-redirect`)
+  .set('Cookie', 'orig=1; replaced=not')
+  .end((err, res) => {
+    try {
+      assert.ifError(err);
+      assert(/orig=1/.test(res.text), '/orig=1');
+      assert(/replaced=not/.test(res.text), '/replaced=not');
+      assert(!/replaced=yes/.test(res.text), '!/replaced=yes');
+      assert(!/from-redir/.test(res.text), '!/from-redir');
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });
should have previously set cookie for subsquent requests when agent is used
- 
done => {
-      const agent = request.agent();
-      agent.get(`${base}/set-cookie`).end(err => {
+            
const agent = request.agent();
+agent.get(`${base}/set-cookie`).end((err) => {
+  assert.ifError(err);
+  agent
+    .get(`${base}/show-cookies`)
+    .set({ Cookie: 'orig=1' })
+    .end((err, res) => {
+      try {
         assert.ifError(err);
-        agent
-          .get(`${base}/show-cookies`)
-          .set({ Cookie: 'orig=1' })
-          .end((err, res) => {
-            try {
-              assert.ifError(err);
-              assert(/orig=1/.test(res.text), 'orig=1/.test');
-              assert(/persist=123/.test(res.text), 'persist=123');
-              done();
-            } catch (err2) {
-              done(err2);
-            }
-          });
-      });
-    }

+        assert(/orig=1/.test(res.text), 'orig=1/.test');
+        assert(/persist=123/.test(res.text), 'persist=123');
+        done();
+      } catch (err_) {
+        done(err_);
+      }
+    });
+});
should follow Location
- 
done => {
-      const redirects = [];
-      request
-        .get(base)
-        .on('redirect', res => {
-          redirects.push(res.headers.location);
-        })
-        .end((err, res) => {
-          try {
-            const arr = ['/movies', '/movies/all', '/movies/all/0'];
-            redirects.should.eql(arr);
-            res.text.should.equal('first movie page');
-            done();
-          } catch (err2) {
-            done(err2);
-          }
-        });
-    }
+ 
const redirects = [];
+request
+  .get(base)
+  .on('redirect', (res) => {
+    redirects.push(res.headers.location);
+  })
+  .end((err, res) => {
+    try {
+      const arr = ['/movies', '/movies/all', '/movies/all/0'];
+      redirects.should.eql(arr);
+      res.text.should.equal('first movie page');
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });
should follow Location with IP override
const redirects = [];
 const url = URL.parse(base);
@@ -4590,10 +4165,26 @@ 
on redirect

   .connect({
     '*': url.hostname
   })
-  .on('redirect', res => {
+  .on('redirect', (res) => {
+    redirects.push(res.headers.location);
+  })
+  .then((res) => {
+    const arr = ['/movies', '/movies/all', '/movies/all/0'];
+    redirects.should.eql(arr);
+    res.text.should.equal('first movie page');
+  });
+
should follow Location with IP:port override
+ 
const redirects = [];
+const url = URL.parse(base);
+return request
+  .get(`http://redir.example.com:9999${url.pathname}`)
+  .connect({
+    '*': { host: url.hostname, port: url.port || 80 }
+  })
+  .on('redirect', (res) => {
     redirects.push(res.headers.location);
   })
-  .then(res => {
+  .then((res) => {
     const arr = ['/movies', '/movies/all', '/movies/all/0'];
     redirects.should.eql(arr);
     res.text.should.equal('first movie page');
@@ -4603,149 +4194,135 @@ 
on redirect

 return request
   .head(base)
   .ok(() => true)
-  .on('redirect', res => {
+  .on('redirect', (res) => {
     redirects.push(res.headers.location);
   })
-  .then(res => {
+  .then((res) => {
     redirects.should.eql([]);
     res.status.should.equal(302);
   });
should follow on HEAD when redirects are set
- 
done => {
-      const redirects = [];
-      request
-        .head(base)
-        .redirects(10)
-        .on('redirect', res => {
-          redirects.push(res.headers.location);
-        })
-        .end((err, res) => {
-          try {
-            const arr = [];
-            arr.push('/movies');
-            arr.push('/movies/all');
-            arr.push('/movies/all/0');
-            redirects.should.eql(arr);
-            assert(!res.text);
-            done();
-          } catch (err2) {
-            done(err2);
-          }
-        });
-    }
+ 
const redirects = [];
+request
+  .head(base)
+  .redirects(10)
+  .on('redirect', (res) => {
+    redirects.push(res.headers.location);
+  })
+  .end((err, res) => {
+    try {
+      const arr = [];
+      arr.push('/movies');
+      arr.push('/movies/all');
+      arr.push('/movies/all/0');
+      redirects.should.eql(arr);
+      assert(!res.text);
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });
should remove Content-* fields
- 
done => {
-      request
-        .post(`${base}/header`)
-        .type('txt')
-        .set('X-Foo', 'bar')
-        .set('X-Bar', 'baz')
-        .send('hey')
-        .end((err, res) => {
-          try {
-            assert(res.body);
-            res.body.should.have.property('x-foo', 'bar');
-            res.body.should.have.property('x-bar', 'baz');
-            res.body.should.not.have.property('content-type');
-            res.body.should.not.have.property('content-length');
-            res.body.should.not.have.property('transfer-encoding');
-            done();
-          } catch (err2) {
-            done(err2);
-          }
-        });
-    }
+ 
request
+  .post(`${base}/header`)
+  .type('txt')
+  .set('X-Foo', 'bar')
+  .set('X-Bar', 'baz')
+  .send('hey')
+  .end((err, res) => {
+    try {
+      assert(res.body);
+      res.body.should.have.property('x-foo', 'bar');
+      res.body.should.have.property('x-bar', 'baz');
+      res.body.should.not.have.property('content-type');
+      res.body.should.not.have.property('content-length');
+      res.body.should.not.have.property('transfer-encoding');
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });
should retain cookies
- 
done => {
-      request
-        .get(`${base}/header`)
-        .set('Cookie', 'foo=bar;')
-        .end((err, res) => {
-          try {
-            assert(res.body);
-            res.body.should.have.property('cookie', 'foo=bar;');
-            done();
-          } catch (err2) {
-            done(err2);
-          }
-        });
-    }
+ 
request
+  .get(`${base}/header`)
+  .set('Cookie', 'foo=bar;')
+  .end((err, res) => {
+    try {
+      assert(res.body);
+      res.body.should.have.property('cookie', 'foo=bar;');
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });
should not resend query parameters
- 
done => {
-      const redirects = [];
-      const query = [];
-      request
-        .get(`${base}/?foo=bar`)
-        .on('redirect', res => {
-          query.push(res.headers.query);
-          redirects.push(res.headers.location);
-        })
-        .end((err, res) => {
-          try {
-            const arr = [];
-            arr.push('/movies');
-            arr.push('/movies/all');
-            arr.push('/movies/all/0');
-            redirects.should.eql(arr);
-            res.text.should.equal('first movie page');
-            query.should.eql(['{"foo":"bar"}', '{}', '{}']);
-            res.headers.query.should.eql('{}');
-            done();
-          } catch (err2) {
-            done(err2);
-          }
-        });
-    }
+ 
const redirects = [];
+const query = [];
+request
+  .get(`${base}/?foo=bar`)
+  .on('redirect', (res) => {
+    query.push(res.headers.query);
+    redirects.push(res.headers.location);
+  })
+  .end((err, res) => {
+    try {
+      const arr = [];
+      arr.push('/movies');
+      arr.push('/movies/all');
+      arr.push('/movies/all/0');
+      redirects.should.eql(arr);
+      res.text.should.equal('first movie page');
+      query.should.eql(['{"foo":"bar"}', '{}', '{}']);
+      res.headers.query.should.eql('{}');
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });
should handle no location header
- 
done => {
-      request.get(`${base}/bad-redirect`).end((err, res) => {
-        try {
-          err.message.should.equal('No location header for redirect');
-          done();
-        } catch (err2) {
-          done(err2);
-        }
-      });
-    }
+ 
request.get(`${base}/bad-redirect`).end((err, res) => {
+  try {
+    err.message.should.equal('No location header for redirect');
+    done();
+  } catch (err_) {
+    done(err_);
+  }
+});

when relative

should redirect to a sibling path
- 
done => {
-        const redirects = [];
-        request
-          .get(`${base}/relative`)
-          .on('redirect', res => {
-            redirects.push(res.headers.location);
-          })
-          .end((err, res) => {
-            try {
-              redirects.should.eql(['tobi']);
-              res.text.should.equal('tobi');
-              done();
-            } catch (err2) {
-              done(err2);
-            }
-          });
-      }
+ 
const redirects = [];
+request
+  .get(`${base}/relative`)
+  .on('redirect', (res) => {
+    redirects.push(res.headers.location);
+  })
+  .end((err, res) => {
+    try {
+      redirects.should.eql(['tobi']);
+      res.text.should.equal('tobi');
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });
should redirect to a parent path
- 
done => {
-        const redirects = [];
-        request
-          .get(`${base}/relative/sub`)
-          .on('redirect', res => {
-            redirects.push(res.headers.location);
-          })
-          .end((err, res) => {
-            try {
-              redirects.should.eql(['../tobi']);
-              res.text.should.equal('tobi');
-              done();
-            } catch (err2) {
-              done(err2);
-            }
-          });
-      }
+ 
const redirects = [];
+request
+  .get(`${base}/relative/sub`)
+  .on('redirect', (res) => {
+    redirects.push(res.headers.location);
+  })
+  .end((err, res) => {
+    try {
+      redirects.should.eql(['../tobi']);
+      res.text.should.equal('tobi');
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });
@@ -4754,28 +4331,26 @@

when relative

req.redirects(n)

should alter the default number of redirects to follow
- 
done => {
-      const redirects = [];
-      request
-        .get(base)
-        .redirects(2)
-        .on('redirect', res => {
-          redirects.push(res.headers.location);
-        })
-        .end((err, res) => {
-          try {
-            const arr = [];
-            assert(res.redirect, 'res.redirect');
-            arr.push('/movies');
-            arr.push('/movies/all');
-            redirects.should.eql(arr);
-            res.text.should.match(/Moved Temporarily|Found/);
-            done();
-          } catch (err2) {
-            done(err2);
-          }
-        });
-    }
+ 
const redirects = [];
+request
+  .get(base)
+  .redirects(2)
+  .on('redirect', (res) => {
+    redirects.push(res.headers.location);
+  })
+  .end((err, res) => {
+    try {
+      const arr = [];
+      assert(res.redirect, 'res.redirect');
+      arr.push('/movies');
+      arr.push('/movies/all');
+      redirects.should.eql(arr);
+      res.text.should.match(/Moved Temporarily|Found/);
+      done();
+    } catch (err_) {
+      done(err_);
+    }
+  });
@@ -4787,10 +4362,10 @@

on POST

.post(`${base}/movie`) .send({ name: 'Tobi' }) .redirects(2) - .on('redirect', res => { + .on('redirect', (res) => { redirects.push(res.headers.location); }) - .then(res => { + .then((res) => { redirects.should.eql(['/movies/all/0']); res.text.should.equal('first movie page'); }); @@ -4801,10 +4376,10 @@

on POST

.type('form') .field('name', 'Tobi') .redirects(2) - .on('redirect', res => { + .on('redirect', (res) => { redirects.push(res.headers.location); }) - .then(res => { + .then((res) => { redirects.should.eql(['/movies/all/0']); res.text.should.equal('first movie page'); }); @@ -4816,96 +4391,88 @@

on POST

response

should act as a readable stream
- 
done => {
-    const req = request.get(base).buffer(false);
-    req.end((err, res) => {
-      if (err) return done(err);
-      let trackEndEvent = 0;
-      let trackCloseEvent = 0;
-      res.on('end', () => {
-        trackEndEvent++;
-        trackEndEvent.should.equal(1);
-        if (!process.env.HTTP2_TEST) {
-          trackCloseEvent.should.equal(0); // close should not have been called
-        }
-        done();
-      });
-      res.on('close', () => {
-        trackCloseEvent++;
-      });
-      (() => {
-        res.pause();
-      }).should.not.throw();
-      (() => {
-        res.resume();
-      }).should.not.throw();
-      (() => {
-        res.destroy();
-      }).should.not.throw();
-    });
-  }
+ 
const req = request.get(base).buffer(false);
+req.end((err, res) => {
+  if (err) return done(err);
+  let trackEndEvent = 0;
+  let trackCloseEvent = 0;
+  res.on('end', () => {
+    trackEndEvent++;
+    trackEndEvent.should.equal(1);
+    if (!process.env.HTTP2_TEST) {
+      trackCloseEvent.should.equal(0); // close should not have been called
+    }
+    done();
+  });
+  res.on('close', () => {
+    trackCloseEvent++;
+  });
+  (() => {
+    res.pause();
+  }).should.not.throw();
+  (() => {
+    res.resume();
+  }).should.not.throw();
+  (() => {
+    res.destroy();
+  }).should.not.throw();
+});

req.serialize(fn)

should take precedence over default parsers
- 
done => {
-    request
-      .post(`${base}/echo`)
-      .send({ foo: 123 })
-      .serialize(data => '{"bar":456}')
-      .end((err, res) => {
-        assert.ifError(err);
-        assert.equal('{"bar":456}', res.text);
-        assert.equal(456, res.body.bar);
-        done();
-      });
-  }
+ 
request
+  .post(`${base}/echo`)
+  .send({ foo: 123 })
+  .serialize((data) => '{"bar":456}')
+  .end((err, res) => {
+    assert.ifError(err);
+    assert.equal('{"bar":456}', res.text);
+    assert.equal(456, res.body.bar);
+    done();
+  });

request.get().set()

should set host header after get()
- 
done => {
-    app.get('/', (req, res) => {
-      assert.equal(req.hostname, 'example.com');
-      res.end();
-    });
-    server = http.createServer(app);
-    server.listen(0, function listening() {
-      request
-        .get(`http://localhost:${server.address().port}`)
-        .set('host', 'example.com')
-        .then(() => {
-          return request
-            .get(`http://example.com:${server.address().port}`)
-            .connect({
-              'example.com': 'localhost',
-              '*': 'fail'
-            });
-        })
-        .then(() => done(), done);
-    });
-  }
+ 
app.get('/', (req, res) => {
+  assert.equal(req.hostname, 'example.com');
+  res.end();
+});
+server = http.createServer(app);
+server.listen(0, function listening() {
+  request
+    .get(`http://localhost:${server.address().port}`)
+    .set('host', 'example.com')
+    .then(() => {
+      return request
+        .get(`http://example.com:${server.address().port}`)
+        .connect({
+          'example.com': 'localhost',
+          '*': 'fail'
+        });
+    })
+    .then(() => done(), done);
+});

res.toError()

should return an Error
- 
done => {
-    request.get(base).end((err, res) => {
-      var err = res.toError();
-      assert.equal(err.status, 400);
-      assert.equal(err.method, 'GET');
-      assert.equal(err.path, '/');
-      assert.equal(err.message, 'cannot GET / (400)');
-      assert.equal(err.text, 'invalid json');
-      done();
-    });
-  }
+ 
request.get(base).end((err, res) => {
+  var err = res.toError();
+  assert.equal(err.status, 400);
+  assert.equal(err.method, 'GET');
+  assert.equal(err.path, '/');
+  assert.equal(err.message, 'cannot GET / (400)');
+  assert.equal(err.text, 'invalid json');
+  done();
+});
@@ -4915,21 +4482,17 @@

[unix-sockets] http

request

path: / (root)
- 
done => {
-      request.get(`${base}/`).end((err, res) => {
-        assert(res.ok);
-        assert.strictEqual('root ok!', res.text);
-        done();
-      });
-    }
+ 
request.get(`${base}/`).end((err, res) => {
+  assert(res.ok);
+  assert.strictEqual('root ok!', res.text);
+  done();
+});
path: /request/path
- 
done => {
-      request.get(`${base}/request/path`).end((err, res) => {
-        assert(res.ok);
-        assert.strictEqual('request path ok!', res.text);
-        done();
-      });
-    }
+ 
request.get(`${base}/request/path`).end((err, res) => {
+  assert(res.ok);
+  assert.strictEqual('request path ok!', res.text);
+  done();
+});
@@ -4941,29 +4504,25 @@

[unix-sockets] https

request

path: / (root)
- 
done => {
-      request
-        .get(`${base}/`)
-        .ca(cacert)
-        .end((err, res) => {
-          assert.ifError(err);
-          assert(res.ok);
-          assert.strictEqual('root ok!', res.text);
-          done();
-        });
-    }
+ 
request
+  .get(`${base}/`)
+  .ca(cacert)
+  .end((err, res) => {
+    assert.ifError(err);
+    assert(res.ok);
+    assert.strictEqual('root ok!', res.text);
+    done();
+  });
path: /request/path
- 
done => {
-      request
-        .get(`${base}/request/path`)
-        .ca(cacert)
-        .end((err, res) => {
-          assert.ifError(err);
-          assert(res.ok);
-          assert.strictEqual('request path ok!', res.text);
-          done();
-        });
-    }
+ 
request
+  .get(`${base}/request/path`)
+  .ca(cacert)
+  .end((err, res) => {
+    assert.ifError(err);
+    assert(res.ok);
+    assert.strictEqual('request path ok!', res.text);
+    done();
+  });
@@ -4971,32 +4530,11 @@

request

req.get()

-
should set a default user-agent
- 
request.get(`${base}/ua`).then(res => {
+        
should not set a default user-agent

+        
request.get(`${base}/ua`).then((res) => {
       assert(res.headers);
-      assert(res.headers['user-agent']);
-      assert(
-        /^node-superagent\/\d+\.\d+\.\d+(?:-[a-z]+\.\d+|$)/.test(
-          res.headers['user-agent']
-        )
-      );
+      assert(!res.headers['user-agent']);
     })

-        
should be able to override user-agent

-        
request
-      .get(`${base}/ua`)
-      .set('User-Agent', 'foo/bar')
-      .then(res => {
-        assert(res.headers);
-        assert.equal(res.headers['user-agent'], 'foo/bar');
-      })

-        
should be able to wipe user-agent

-        
request
-      .get(`${base}/ua`)
-      .unset('User-Agent')
-      .then(res => {
-        assert(res.headers);
-        assert.equal(res.headers['user-agent'], void 0);
-      })
@@ -5036,7 +4574,7 @@

utils.parseLinks(str)

Fork me on GitHub - + +