Merge pull request #94 from OleksiiSliusarenko/master

Possibility to overwrite `options` in retry strategy

Author: FGRibreau

README.md

@@ -113,13 +113,30 @@ A retry strategy let you specify when request-retry should retry a request
  * @param  {Null | Object} err
  * @param  {Object} response
  * @param  {Object} body
+ * @param  {Object} options copy 
  * @return {Boolean} true if the request should be retried
  */
-function myRetryStrategy(err, response, body){
+function myRetryStrategy(err, response, body, options){
   // retry the request if we had an error or if the response was a 'Bad Gateway'
   return err || response.statusCode === 502;
 }
 
+/**
+ * @param  {Null | Object} err
+ * @param  {Object} response
+ * @param  {Object} body
+ * @param  {Object} options copy 
+ * @return {Object} mustRetry: {Boolean} true if the request should be retried
+ *                  options: {Object} new options for request
+ */
+function myRetryStrategy(err, response, body, options){
+  options.url = 'new url'; //you can overwrite some attributes or create new object 
+  return {
+    mustRetry: err || response.statusCode === 502,
+    options: options, //then it should be passed back, it will be used for new requests
+  }
+}
+
 request({
   url: 'https://api.domain.com/v1/a/b'
   json:true,

index.js

@@ -80,7 +80,7 @@ function Request(url, options, f, retryConfig) {
 
   /**
    * Return true if the request should be retried
-   * @type {Function} (err, response) -> Boolean
+   * @type {Function} (err, response, body, options) -> [Boolean, Object (optional)]
    */
   this.retryStrategy = _.isFunction(options.retryStrategy) ? options.retryStrategy : RetryStrategies.HTTPOrNetworkError;
 
@@ -130,7 +130,15 @@ Request.prototype._tryUntilFail = function () {
       err.attempts = this.attempts;
     }
 
-    if (this.retryStrategy(err, response, body) && this.maxAttempts > 0) {
+    var mustRetry = this.retryStrategy(err, response, body, _.cloneDeep(this.options));
+    if (_.isObject(mustRetry)) {
+      if (_.isObject(mustRetry.options)) {
+        this.options = mustRetry.options; //if retryStrategy supposes different request options for retry
+      }
+      mustRetry = mustRetry.mustRetry;
+    }
+
+    if (mustRetry && this.maxAttempts > 0) {
       this._timeout = setTimeout(this._tryUntilFail.bind(this), this.delayStrategy.call(this, err, response, body));
       return;
     }

test/attempts.test.js

@@ -38,6 +38,7 @@ describe('Request attempts', function () {
   });
 
   it('should call delay strategy 2 times after some retries', function (done) {
+    this.timeout(3000);
     var mockDelayStrategy = sinon.stub().returns(500);
     var startTime = process.hrtime();
     request({

test/strategies.test.js

@@ -4,17 +4,66 @@ var request = require('../');
 var t = require('chai').assert;
 
 describe('RetryStrategies', function () {
-  it('should have a strategy `HTTPError` to only retry on HTTP errors', function () {
-    checkHTTPErrors(request.RetryStrategies.HTTPError);
-  });
 
-  it('should have a strategy `NetworkError` to only retry on nodejs network errors', function () {
-    checkNetworkErrors(request.RetryStrategies.NetworkError, request.RetryStrategies.NetworkError.RETRIABLE_ERRORS);
+  describe('Default strategies', function () {
+    it('should have a strategy `HTTPError` to only retry on HTTP errors', function () {
+      checkHTTPErrors(request.RetryStrategies.HTTPError);
+    });
+
+    it('should have a strategy `NetworkError` to only retry on nodejs network errors', function () {
+      checkNetworkErrors(request.RetryStrategies.NetworkError, request.RetryStrategies.NetworkError.RETRIABLE_ERRORS);
+    });
+
+    it('should have a strategy `HTTPOrNetworkError` to only retry on nodejs network and HTTP errors', function () {
+      checkHTTPErrors(request.RetryStrategies.HTTPOrNetworkError);
+      checkNetworkErrors(request.RetryStrategies.HTTPOrNetworkError, request.RetryStrategies.NetworkError.RETRIABLE_ERRORS);
+    });
   });
 
-  it('should have a strategy `HTTPOrNetworkError` to only retry on nodejs network and HTTP errors', function () {
-    checkHTTPErrors(request.RetryStrategies.HTTPOrNetworkError);
-    checkNetworkErrors(request.RetryStrategies.HTTPOrNetworkError, request.RetryStrategies.NetworkError.RETRIABLE_ERRORS);
+  describe('Custom strategies', function () {
+    it('should overwrite `options` object if strategy returned it', function (done) {
+      var strategy = function (err, response, body, options) {
+        options.url = 'http://www.filltext.com/?rows=1&err=200'; //overwrite url to return 200
+        return {
+          mustRetry: true,
+          options: options,
+        };
+      };
+
+      request({
+        url: 'http://www.filltext.com/?rows=1&err=500', // returns a 500 status
+        maxAttempts: 3,
+        retryDelay: 100,
+        retryStrategy: strategy
+      }, function(err, response, body) {
+        if(err) done(err);
+
+        t.strictEqual(200, response.statusCode);
+        done();
+      });
+    });
+
+    it('should not overwrite `options` object if strategy did not returned it', function (done) {
+      var strategy = function (err, response, body, options) {
+        options.url = 'http://www.filltext.com/?rows=1&err=200'; //overwrite url to return 200
+        //do not return `options`
+        return {
+          mustRetry: true,
+        };
+      };
+
+      request({
+        url: 'http://www.filltext.com/?rows=1&err=500', // returns a 500 status
+        maxAttempts: 3,
+        retryDelay: 100,
+        retryStrategy: strategy
+      }, function(err, response, body) {
+        if(err) done(err);
+
+        t.strictEqual(500, response.statusCode);
+        done();
+      });
+    })
   });
 });