@mimik/request-retry 3.0.2 → 4.0.0

package/eslint.config.js

@@ -0,0 +1,63 @@
+import importPlugin from 'eslint-plugin-import';
+import js from '@eslint/js';
+import processDoc from '@mimik/eslint-plugin-document-env';
+import stylistic from '@stylistic/eslint-plugin';
+
+const MAX_LENGTH_LINE = 180;
+const MAX_FUNCTION_PARAMETERS = 6;
+const MAX_LINES_IN_FILES = 600;
+const MAX_LINES_IN_FUNCTION = 150;
+const MAX_STATEMENTS_IN_FUNCTION = 45;
+const MIN_KEYS_IN_OBJECT = 10;
+const MAX_COMPLEXITY = 30;
+
+export default [
+  {
+    ignores: ['mochawesome-report/**', 'node_modules/**', 'dist/**'],
+  },
+  importPlugin.flatConfigs.recommended,
+  stylistic.configs['recommended-flat'],
+  js.configs.all,
+  {
+    plugins: {
+      processDoc,
+    },
+    languageOptions: {
+      ecmaVersion: 2022,
+      globals: {
+        console: 'readonly',
+        describe: 'readonly',
+        it: 'readonly',
+        require: 'readonly',
+      },
+      sourceType: 'module',
+    },
+    rules: {
+      '@stylistic/brace-style': ['warn', 'stroustrup', { allowSingleLine: true }],
+      '@stylistic/line-comment-position': ['off'],
+      '@stylistic/semi': ['error', 'always'],
+      'capitalized-comments': ['off'],
+      'complexity': ['error', MAX_COMPLEXITY],
+      'curly': ['off'],
+      'id-length': ['error', { exceptions: ['x', 'y', 'z', 'i', 'j', 'k'] }],
+      'import/no-extraneous-dependencies': ['error', { devDependencies: true }],
+      'import/no-unresolved': ['error', { amd: true, caseSensitiveStrict: true, commonjs: true }],
+      'init-declarations': ['off'],
+      'linebreak-style': ['off'],
+      'max-len': ['warn', MAX_LENGTH_LINE, { ignoreComments: true }],
+      'max-lines': ['warn', { max: MAX_LINES_IN_FILES, skipComments: true }],
+      'max-lines-per-function': ['warn', { max: MAX_LINES_IN_FUNCTION, skipComments: true }],
+      'max-params': ['error', MAX_FUNCTION_PARAMETERS],
+      'max-statements': ['warn', MAX_STATEMENTS_IN_FUNCTION],
+      'no-confusing-arrow': ['off'], // arrow isnt confusing
+      'no-inline-comments': ['off'],
+      'no-process-env': ['error'],
+      'no-ternary': ['off'],
+      'no-undefined': ['off'],
+      'one-var': ['error', 'never'],
+      'processDoc/validate-document-env': ['error'],
+      'quotes': ['warn', 'single'],
+      'sort-keys': ['error', 'asc', { caseSensitive: true, minKeys: MIN_KEYS_IN_OBJECT, natural: false }],
+    },
+  },
+];

package/index.js

@@ -1,15 +1,22 @@
-const Promise = require('bluebird');
-
-const logger = require('@mimik/sumologic-winston-logger');
-const { getRichError } = require('@mimik/response-helper');
-const { getCorrelationId, setUserAgent } = require('@mimik/request-helper');
-const {
-  validateOptions,
+import {
   calculateDelay,
   isRetry,
   setResponse,
-} = require('./lib/validate');
-const { rp } = require('./lib/rp-axios-wrapper');
+  validateOptions,
+} from './lib/validate.js';
+import {
+  clearTimeout,
+  setTimeout,
+} from 'timers';
+import {
+  getCorrelationId,
+  setUserAgent,
+} from '@mimik/request-helper';
+import Promise from 'bluebird';
+import { getRichError } from '@mimik/response-helper';
+import logger from '@mimik/sumologic-winston-logger';
+import process from 'process';
+import { rp } from './lib/rp-axios-wrapper.js';
 
 const DEFAULT_RESPONSE_NAME = 'response';
 const DEFAULT_LOGLEVEL_DETAILS = 'full';
@@ -17,6 +24,16 @@ const DEFAULT_LOGLEVEL_RESPONSE = 'info';
 const DEFAULT_LOGLEVEL_ERROR = 'warn';
 const DEFAULT_LOGLEVEL_REQUEST = 'info';
 
+const MILLI_SECONDS = 0;
+const MILLI_NANO_SECONDS = 1;
+const INCR = 1;
+const MILLI = 1000;
+const NANO = 1e6;
+const EMPTY = 0;
+const NONE = 0;
+const OK_RESPONSE = 200;
+const SYSTEM_ERROR = 500;
+
 Promise.config({ cancellation: true });
 
 /**
@@ -82,12 +99,12 @@ const rpRetry = (origOptions) => {
   const criteria = validateOptions(options, correlationId);
   const { logLevel } = criteria;
   const logLevelLength = Object.keys(logLevel).length;
-  let nbRetries = 0;
+  let nbRetries = NONE;
   let mainTimeout;
   const measure = (statusCode) => {
     if (metrics && metrics.HTTPRequestDuration) {
       const elapsedHrTime = process.hrtime(startHrTime);
-      const elapsedTimeInMs = elapsedHrTime[0] * 1000 + elapsedHrTime[1] / 1e6;
+      const elapsedTimeInMs = elapsedHrTime[MILLI_SECONDS] * MILLI + elapsedHrTime[MILLI_NANO_SECONDS] / NANO;
 
       metrics.HTTPRequestDuration
         .labels('rpRetry', options.method, metrics.url || enteredUrl, enteredUrl.includes('?'), statusCode)
@@ -100,7 +117,7 @@ const rpRetry = (origOptions) => {
   const optionsInfo = { ...options };
   delete optionsInfo.metrics;
 
-  const retryProcess = (nbRetry) => rp(options)
+  const retryProcess = nbRetry => rp(options)
     .then((response) => {
       const info = { options: optionsInfo, nbRetries, errors };
 
@@ -108,7 +125,7 @@ const rpRetry = (origOptions) => {
         info[logLevel.responseName] = setResponse(response, logLevel.responseDetails);
         logger[logLevel.response]('request response', info, correlationId);
       }
-      else if (logLevelLength === 0) {
+      else if (logLevelLength === EMPTY) {
         info[DEFAULT_RESPONSE_NAME] = setResponse(response, DEFAULT_LOGLEVEL_DETAILS);
         logger[DEFAULT_LOGLEVEL_RESPONSE]('request response', info, correlationId);
       }
@@ -116,16 +133,16 @@ const rpRetry = (origOptions) => {
     })
     .catch((err) => {
       if ((nbRetry < criteria.retries) && isRetry(options, nbRetry, criteria, err, correlationId)) {
-        nbRetries = nbRetry + 1;
+        nbRetries = nbRetry + INCR;
         errors.push(err);
         const delayPromise = Promise.delay(calculateDelay(options, nbRetry, criteria, err, correlationId));
 
         delayPromises.unshift(delayPromise);
-        return delayPromise.then(() => retryProcess(nbRetry + 1));
+        return delayPromise.then(() => retryProcess(nbRetry + INCR));
       }
       const error = err;
 
-      if (nbRetries !== 0) {
+      if (nbRetries !== NONE) {
         if (!error.info) error.info = {};
         error.info.retry = {
           nbRetries,
@@ -137,18 +154,18 @@ const rpRetry = (origOptions) => {
         'request error response',
         { options: optionsInfo },
         error,
-        logLevel.error || ((logLevelLength === 0) ? DEFAULT_LOGLEVEL_ERROR : undefined),
+        logLevel.error || ((logLevelLength === EMPTY) ? DEFAULT_LOGLEVEL_ERROR : undefined),
         correlationId,
       );
     });
 
-  const retryPromise = retryProcess(0);
+  const retryPromise = retryProcess(NONE);
   const mainTimeoutPromise = new Promise((resolve, reject) => {
     mainTimeout = setTimeout(() => {
-      delayPromises.forEach((delayPromise) => delayPromise.cancel(`retry timeout delay, ${criteria.timeout}, ${nbRetries}`));
+      delayPromises.forEach(delayPromise => delayPromise.cancel(`retry timeout delay, ${criteria.timeout}, ${nbRetries}`));
       let error = new Error('retry timeout');
 
-      if (nbRetries !== 0) {
+      if (nbRetries !== NONE) {
         error.info = { retry: { nbRetries, errors } };
       }
       error.name = 'TimeoutError';
@@ -157,30 +174,30 @@ const rpRetry = (origOptions) => {
         'request error response',
         { options: optionsInfo },
         error,
-        logLevel.error || ((logLevelLength === 0) ? DEFAULT_LOGLEVEL_ERROR : undefined),
+        logLevel.error || ((logLevelLength === EMPTY) ? DEFAULT_LOGLEVEL_ERROR : undefined),
         correlationId,
       );
       reject(error);
-    }, criteria.timeout * 1000);
+    }, criteria.timeout * MILLI);
   });
 
   if (logLevel.request) logger[logLevel.request]('making a request', { options: optionsInfo, criteria }, correlationId);
-  else if (logLevelLength === 0) logger[DEFAULT_LOGLEVEL_REQUEST]('making a request', { options: optionsInfo, criteria }, correlationId);
+  else if (logLevelLength === EMPTY) logger[DEFAULT_LOGLEVEL_REQUEST]('making a request', { options: optionsInfo, criteria }, correlationId);
   return Promise.race([retryPromise, mainTimeoutPromise])
     .then((result) => {
       mainTimeoutPromise.cancel('main timeout');
       clearTimeout(mainTimeout);
-      measure(200);
+      measure(OK_RESPONSE);
       return result;
     })
     .catch((err) => {
       mainTimeoutPromise.cancel(`main timeout error: ${err.message}`);
       clearTimeout(mainTimeout);
-      measure(err.statusCode || 500);
+      measure(err.statusCode || SYSTEM_ERROR);
       throw err;
     });
 };
 
-module.exports = {
+export {
   rpRetry,
 };

package/lib/rp-axios-wrapper.js

@@ -1,7 +1,6 @@
-const axios = require('axios');
-const clone = require('lodash.clone');
-
-const { getRichError } = require('@mimik/response-helper');
+import axios from 'axios';
+import clone from 'lodash.clone';
+import { getRichError } from '@mimik/response-helper';
 
 const rp = (origOptions) => {
   const options = clone(origOptions);
@@ -43,6 +42,6 @@ const rp = (origOptions) => {
     });
 };
 
-module.exports = {
+export {
   rp,
 };

package/lib/validate.js

@@ -1,23 +1,29 @@
-const logger = require('@mimik/sumologic-winston-logger');
+import logger from '@mimik/sumologic-winston-logger';
 
 const DETAILS = ['full', 'type', 'count'];
-const TYPE = DETAILS[1];
+const [, TYPE/* type */] = DETAILS;
 const RESPONSE = 'response';
-const DEFAULT_LOGLEVEL = logger.LEVELS[5]; // silly
+const [, , , , , DEFAULT_LOGLEVEL/* 'silly' */] = logger.LEVELS;
 const DEFAULT_RETRIES = 2;
 const MIN_RETRIES = 0;
 const MAX_RETRIES = 15;
 const DEFAULT_DELAY = 1000; // in ms
 const MIN_DELAY = 20; // in ms
 const MAX_DELAY = 30000; // in ms
+const NO_DELAY = 0;
 const DEFAULT_TIMEOUT = 50; // in seconds
 const MIN_TIMEOUT = 10; // in seconds
 const MAX_TIMEOUT = 120; // in seconds
+const TOO_MANY_REQUESTS_ERROR = 429;
+const EMPTY = 0;
+const SYSTEM_RANGE = 5;
+const SYSTEM_RANGE_EXTRACT = 100;
+const ARG_ERROR = 1;
 
 const defaultRetry = (...args) => {
-  const { statusCode } = args[1]; // err
+  const { statusCode } = args[ARG_ERROR]; // err
 
-  return (statusCode && (Math.floor(statusCode / 100) === 5 || statusCode === 429)) || (!statusCode && !args[1].message.includes('Invalid URI'));
+  return (statusCode && (Math.floor(statusCode / SYSTEM_RANGE_EXTRACT) === SYSTEM_RANGE || statusCode === TOO_MANY_REQUESTS_ERROR)) || (!statusCode && !args[ARG_ERROR].message.includes('Invalid URI'));
 };
 const unknownRetry = () => true;
 const defaultDelay = () => DEFAULT_DELAY;
@@ -74,7 +80,7 @@ const validateOptions = (options, correlationId) => {
   };
   const validateResponseName = (val, name, defaultValue) => {
     if (!val && val !== '') return defaultValue;
-    if (typeof val !== 'string' || val.length === 0 || val.trim().length === 0) {
+    if (typeof val !== 'string' || val.length === EMPTY || val.trim().length === EMPTY) {
       logger.warn(`invalid logLevel.${name}, reset to default`, { name, value: val, defaultValue }, correlationId);
       return defaultValue;
     }
@@ -86,29 +92,29 @@ const validateOptions = (options, correlationId) => {
   delay = validateValue(delay, 'delay', DEFAULT_DELAY, MIN_DELAY, MAX_DELAY);
   retries = validateValue(retries, 'retries', DEFAULT_RETRIES, MIN_RETRIES, MAX_RETRIES);
   if (typeof delayStrategy !== 'function') {
-    if (!delayStrategy) delayStrategy = setDelay;
-    else {
+    if (delayStrategy) {
       logger.warn('invalid delayStrategy, using delay', { strategyType: typeof delayStrategy, delay, default: DEFAULT_DELAY }, correlationId);
       delayStrategy = setDelay;
     }
+    else delayStrategy = setDelay;
   }
   if (typeof retryStrategy !== 'function') {
-    if (!retryStrategy) retryStrategy = defaultRetry;
-    else {
+    if (retryStrategy) {
       logger.warn('invalid retryStrategy, ignoring', { strategyType: typeof retryStrategy, using: unknownRetry }, correlationId);
       retryStrategy = unknownRetry;
     }
+    else retryStrategy = defaultRetry;
   }
-  if (!logLevel) {
-    logLevel = {};
-  }
-  else {
+  if (logLevel) {
     logLevel.response = validateLogLevel(logLevel, 'response');
     logLevel.error = validateLogLevel(logLevel, 'error');
     logLevel.request = validateLogLevel(logLevel, 'request');
     logLevel.responseDetails = validateResponseDetails(logLevel.responseDetails, 'responseDetails', TYPE);
     logLevel.responseName = validateResponseName(logLevel.responseName, 'responseName', RESPONSE);
   }
+  else {
+    logLevel = {};
+  }
   return {
     delay,
     delayStrategy,
@@ -122,7 +128,9 @@ const validateOptions = (options, correlationId) => {
 const calculateDelay = (options, nbRetry, criteria, err, correlationId) => {
   let calcDelay;
 
-  try { calcDelay = criteria.delayStrategy(nbRetry, err, options, correlationId); }
+  try {
+    calcDelay = criteria.delayStrategy(nbRetry, err, options, correlationId);
+  }
   catch (error) {
     logger.warn('bad delay strategy', { error }, correlationId);
     calcDelay = criteria.delay;
@@ -131,7 +139,7 @@ const calculateDelay = (options, nbRetry, criteria, err, correlationId) => {
     logger.warn('bad delay strategy', { error: `return of delayStrategy is a ${typeof calcDelay}` }, correlationId);
     calcDelay = criteria.delay;
   }
-  else if (calcDelay > MAX_DELAY || calcDelay <= 0) {
+  else if (calcDelay > MAX_DELAY || calcDelay <= NO_DELAY) {
     logger.warn('calculated delay out of scope: using delay or default', { calcDelay, delay: criteria.delay, default: DEFAULT_DELAY }, correlationId);
     calcDelay = criteria.delay;
   }
@@ -141,7 +149,9 @@ const calculateDelay = (options, nbRetry, criteria, err, correlationId) => {
 const isRetry = (options, nbRetry, criteria, err, correlationId) => {
   let iRetry;
 
-  try { iRetry = criteria.retryStrategy(nbRetry, err, options, correlationId); }
+  try {
+    iRetry = criteria.retryStrategy(nbRetry, err, options, correlationId);
+  }
   catch (error) {
     logger.warn('bad retry strategy', { error }, correlationId);
     iRetry = true;
@@ -165,9 +175,9 @@ const setResponse = (response, details) => {
   return response;
 };
 
-module.exports = {
-  validateOptions,
+export {
   calculateDelay,
   isRetry,
   setResponse,
+  validateOptions,
 };

package/manual-test/httpMock.js

@@ -1,6 +1,8 @@
 /* eslint-disable no-console */
-const express = require('express');
-const bodyParser = require('body-parser');
+import bodyParser from 'body-parser';
+import express from 'express';
+
+const PORT = 9000;
 
 const app = express();
 
@@ -11,6 +13,6 @@ app.get('/success', (req, res) => {
   res.send({ statusCode: 200 });
 });
 
-app.listen(9000, () => {
-  console.log('----->', `retry mock at ${9000}`);
+app.listen(PORT, () => {
+  console.log('----->', `retry mock at ${PORT}`);
 });

package/manual-test/man.js

@@ -1,7 +1,9 @@
 /* eslint-disable no-console */
-require('./testEnv');
+import './testEnv';
 
-const { rpRetry } = require('../index');
+import { rpRetry } from '../index.js';
+
+const DELAY = 1000;
 
 const correlationId = `--request-retry-test--/${new Date().toISOString()}`;
 
@@ -15,9 +17,9 @@ const options = {
   retry: {},
 };
 
-options.retry.delayStrategy = () => 1000;
+options.retry.delayStrategy = () => DELAY;
 options.retry.timeout = 10;
 options.retry.retries = 2;
 
 rpRetry(options)
-  .catch((err) => console.log(err));
+  .catch(err => console.log(err));

package/manual-test/retryMockMan.js

@@ -1,6 +1,10 @@
 /* eslint-disable no-console */
-const express = require('express');
-const bodyParser = require('body-parser');
+import bodyParser from 'body-parser';
+import express from 'express';
+import { setTimeout } from 'timers';
+
+const NONE = 0;
+const INCR = 1;
 
 const app = express();
 const config = {
@@ -23,7 +27,7 @@ let message;
 
 app.use(bodyParser.json());
 app.get(`${config.base}${config.path}`, (req, res) => {
-  if (nbRequest === 0) message = 'Recieved first request';
+  if (nbRequest === NONE) message = 'Recieved first request';
   else {
     const timeLap = Date.now() - time;
 
@@ -37,7 +41,7 @@ app.get(`${config.base}${config.path}`, (req, res) => {
     res.send({ statusCode: config.get.success });
     return;
   }
-  nbRequest += 1;
+  nbRequest += INCR;
   setTimeout(() => {
     res.statusCode = config.get.error;
     res.send({ statusCode: config.get.error });

package/manual-test/testEnv.js

@@ -1,4 +1,5 @@
 /* eslint no-process-env: "off" */
+import process from 'process';
 
 /**
  * The following environment variables are set for the test:
@@ -12,9 +13,10 @@
  * | CONSOLE_LEVEL | log level to diplay | debug
  * | LOG_MODE | log mode | none
  */
-
-// process.env.SUMO_LOGIC_ENDPOINT = 'http://localhost:9080/logs/';
-// process.env.SUMO_LOGIC_COLLECTOR_CODE = '1234';
+/*
+ *process.env.SUMO_LOGIC_ENDPOINT = 'http://localhost:9080/logs/';
+ *process.env.SUMO_LOGIC_COLLECTOR_CODE = '1234';
+ */
 process.env.SUMO_LOGIC_ENDPOINT = null;
 process.env.SUMO_LOGIC_COLLECTOR_CODE = null;
 process.env.NO_STACK = 'yes';

package/manual-test/testRace.js

@@ -1,9 +1,18 @@
 /* eslint-disable no-console */
+import {
+  clearTimeout,
+  setTimeout,
+} from 'timers';
+
+const INCR = 1;
+const MAX_INCR = 100000000;
+const NO_RESULT = 0;
+
 const doSomething = () => {
   let add = 0;
 
-  for (let i = 0; i < 100000000; i += 1) {
-    add += 1;
+  for (let i = 0; i < MAX_INCR; i += INCR) {
+    add += INCR;
     console.log(add);
   }
   return add;
@@ -16,10 +25,12 @@ const race = () => {
     throw new Error('timeout');
   }, timeout);
 
-  try { result = doSomething(); }
+  try {
+    result = doSomething();
+  }
   catch (err) {
     console.log(err);
-    result = 0;
+    result = NO_RESULT;
   }
   clearTimeout(mainTimeout);
   return result;

package/manual-test/testRetry.js

@@ -1,6 +1,7 @@
 /* eslint-disable no-console */
-require('../test/testEnv');
-const { rpRetry } = require('../index');
+import '../test/testEnv.js';
+
+import { rpRetry } from '../index.js';
 
 const options = {
   method: 'GET',
@@ -10,51 +11,53 @@ const options = {
   },
   json: true,
   timeout: 20000,
-  // retry: {
-  // all default: maxRetry: 2, retryDelay: 1000ms, maxTimeout: 50s, logLevel: 3 silly, type response, retryDelayStrategy: setDelay, retryStrategy: defaultRetry
-  // retries: -1,  // => 0
-  // retries: 20, // => 15
-  // retries: 'joe', // => 2
-  // retries: 0, // OK
-  // delay: 0, // => 20ms
-  // delay: 100000, // => 30000ms
-  // delay: 'joe', // => 1000ms
-  // delay: 1, // => 20ms
-  // delayStrategy: 'joe', // => setDelay returning retryDelay
-  // delayStrategy: function badDelay() { return 'joe' }, // => no change then bad delay strategy => retryDelay
-  // delayStrategy: function userDelay(...args) { return (Math.pow(2, args[0]) * 100) + Math.floor(Math.random() * 50) }, // OK
-  // retryStrategy: 'joe', // => unknowRetry returning false
-  // retryStrategy: function badRetry() { return 'joe' }, // => no change then bad retry strategy => false
-  // retryStrategy: function userRetry(...args) { // OK
-  //   const { statusCode } = args[1]; // err
-  //
-  //   return statusCode && (Math.floor(statusCode/100) !== 5 || statusCode !== 429); // retry if there is no statusCode or if there is 500 range statucCode or 429
-  // },
-  // retryStrategy: function invalidRetry(...args) { // defaultRetry
-  //   const { statusCode } = args[34]; // null value
-  //
-  //   return true // no retry
-  // },
-  // timeout: 0, // => 10s
-  // timeout: 150, // => 120s
-  // timeout: 'joe', // => 50s
-  // logLevel: {
-  //   response: 'test', // silly with warning
-  //   error: 1234, // => silly with warning
-  //   request: null, // => silly no warning
-  //   responseDetails: 'test', // => type with warning
-  //   responseName: '', // => response with warning
-  // },
-  // logLevel: {
-  //   response: 'info', // ok all the other value to default no warning
-  // },
-  // }
+  /*
+   * retry: {
+   * all default: maxRetry: 2, retryDelay: 1000ms, maxTimeout: 50s, logLevel: 3 silly, type response, retryDelayStrategy: setDelay, retryStrategy: defaultRetry
+   * retries: -1,  // => 0
+   * retries: 20, // => 15
+   * retries: 'joe', // => 2
+   * retries: 0, // OK
+   * delay: 0, // => 20ms
+   * delay: 100000, // => 30000ms
+   * delay: 'joe', // => 1000ms
+   * delay: 1, // => 20ms
+   * delayStrategy: 'joe', // => setDelay returning retryDelay
+   * delayStrategy: function badDelay() { return 'joe' }, // => no change then bad delay strategy => retryDelay
+   * delayStrategy: function userDelay(...args) { return (Math.pow(2, args[0]) * 100) + Math.floor(Math.random() * 50) }, // OK
+   * retryStrategy: 'joe', // => unknowRetry returning false
+   * retryStrategy: function badRetry() { return 'joe' }, // => no change then bad retry strategy => false
+   * retryStrategy: function userRetry(...args) { // OK
+   *   const { statusCode } = args[1]; // err
+   *
+   *   return statusCode && (Math.floor(statusCode/100) !== 5 || statusCode !== 429); // retry if there is no statusCode or if there is 500 range statucCode or 429
+   * },
+   * retryStrategy: function invalidRetry(...args) { // defaultRetry
+   *   const { statusCode } = args[34]; // null value
+   *
+   *   return true // no retry
+   * },
+   * timeout: 0, // => 10s
+   * timeout: 150, // => 120s
+   * timeout: 'joe', // => 50s
+   * logLevel: {
+   *   response: 'test', // silly with warning
+   *   error: 1234, // => silly with warning
+   *   request: null, // => silly no warning
+   *   responseDetails: 'test', // => type with warning
+   *   responseName: '', // => response with warning
+   * },
+   * logLevel: {
+   *   response: 'info', // ok all the other value to default no warning
+   * },
+   * }
+   */
 };
 
 const sDate = Date.now();
 
 rpRetry(options)
-  .then((response) => console.log('success', { response: typeof response }, Date.now() - sDate))
+  .then(response => console.log('success', { response: typeof response }, Date.now() - sDate))
   .catch((err) => {
     console.log('failure', { error: err, info: err.info }, Date.now() - sDate);
   });

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@mimik/request-retry",
-  "version": "3.0.2",
+  "version": "4.0.0",
   "description": "Request retry wrapping axios",
-  "main": "index.js",
+  "main": "./index.js",
+  "type": "module",
   "scripts": {
-    "lint": "eslint --ignore-path .gitignore .",
+    "lint": "eslint . --no-error-on-unmatched-pattern",
     "docs": "jsdoc2md index.js > README.md",
     "test": "mocha --reporter mochawesome --bail --check-leaks test/",
-    "test-ci": "nyc --reporter=lcov --reporter=text npm test",
+    "test-ci": "c8 --reporter=lcov --reporter=text npm test --exit",
     "prepublishOnly": "npm run docs && npm run lint && npm run test-ci",
-    "commit-ready": "npm run docs && npm run lint && npm run test-ci",
-    "prepare": "husky install"
+    "commit-ready": "npm run docs && npm run lint && npm run test-ci"
   },
   "husky": {
     "hooks": {
@@ -29,31 +29,28 @@
     "url": "https://bitbucket.org/mimiktech/request-retry"
   },
   "dependencies": {
-    "@mimik/request-helper": "^1.7.11",
-    "@mimik/response-helper": "^3.1.0",
-    "@mimik/sumologic-winston-logger": "^1.6.22",
-    "axios": "1.7.7",
+    "@mimik/request-helper": "^2.0.1",
+    "@mimik/response-helper": "^4.0.0",
+    "@mimik/sumologic-winston-logger": "^2.0.2",
+    "axios": "1.8.4",
     "bluebird": "3.7.2",
     "lodash.clone": "4.5.0"
   },
   "devDependencies": {
-    "@mimik/eslint-plugin-dependencies": "^2.4.6",
-    "@mimik/eslint-plugin-document-env": "^1.0.6",
-    "acorn": "8.12.1",
+    "@eslint/js": "9.23.0",
+    "@mimik/eslint-plugin-document-env": "^2.0.5",
+    "@stylistic/eslint-plugin": "4.2.0",
+    "acorn": "8.14.1",
     "body-parser": "1.20.3",
-    "chai": "4.5.0",
-    "eslint": "8.57.1",
-    "eslint-config-airbnb": "19.0.4",
+    "c8": "10.1.3",
+    "chai": "5.2.0",
+    "eslint": "9.23.0",
     "eslint-plugin-import": "2.31.0",
-    "eslint-plugin-jsx-a11y": "6.10.0",
-    "eslint-plugin-react": "7.37.1",
-    "eslint-plugin-react-hooks": "4.6.2",
-    "express": "4.21.0",
-    "husky": "9.1.6",
-    "jsdoc-to-markdown": "9.0.2",
-    "mocha": "10.7.3",
+    "express": "4.21.2",
+    "husky": "9.1.7",
+    "jsdoc-to-markdown": "9.1.1",
+    "mocha": "11.1.0",
     "mochawesome": "7.1.3",
-    "nyc": "17.1.0",
-    "sinon": "19.0.2"
+    "sinon": "20.0.0"
   }
 }

package/test/retryMock.js

@@ -1,6 +1,13 @@
 /* eslint-disable no-console */
-const express = require('express');
-const bodyParser = require('body-parser');
+import bodyParser from 'body-parser';
+import express from 'express';
+import process from 'process';
+import { setTimeout } from 'timers';
+
+const NONE = 0;
+const INCR = 1;
+const TIMEOUT = 3000;
+const EXIT_NORMAL = 0;
 
 const app = express();
 const config = {
@@ -22,7 +29,7 @@ let message;
 
 app.use(bodyParser.json());
 app.get(`${config.base}${config.path}`, (req, res) => {
-  if (nbRequest === 0) message = 'Recieved first request';
+  if (nbRequest === NONE) message = 'Recieved first request';
   else {
     const timeLap = Date.now() - time;
 
@@ -36,7 +43,7 @@ app.get(`${config.base}${config.path}`, (req, res) => {
     res.send({ statusCode: config.get.success });
     return;
   }
-  nbRequest += 1;
+  nbRequest += INCR;
   res.statusCode = config.get.error;
 
   res.send({ statusCode: config.get.error });
@@ -51,8 +58,8 @@ app.get('/stop', (req, res) => {
   res.statusCode = config.get.success;
   res.send({ statusCode: config.get.success });
   setTimeout(() => {
-    process.exit(0);
-  }, 3000);
+    process.exit(EXIT_NORMAL);
+  }, TIMEOUT);
 });
 
 const listen = () => {
@@ -61,6 +68,6 @@ const listen = () => {
   });
 };
 
-module.exports = {
+export {
   listen,
 };

package/test/rpRetry.spec.js

@@ -1,27 +1,36 @@
-const chai = require('chai');
-const sinon = require('sinon');
-const { beforeEach, afterEach } = require('mocha');
-require('./testEnv');
+import './testEnv.js';
+import { afterEach, before, beforeEach, describe, it } from 'mocha';
+import { assert, spy } from 'sinon';
+import { expect, should } from 'chai';
+import { getCorrelationId } from '@mimik/request-helper';
+import { listen } from './retryMock.js';
+import logger from '@mimik/sumologic-winston-logger';
+import { rpRetry } from '../index.js';
 
-const logger = require('@mimik/sumologic-winston-logger');
-const { getCorrelationId } = require('@mimik/request-helper');
+const TIMEOUT = 50000;
+const RETRY_DELAY = 10000;
+const RETRY_TIMEOUT = 10;
+const RETRY_RETRIES = 2;
+const DELAY_STRATEGY_RESPONSE_1 = -20;
+const DELAY_STRATEGY_RESPONSE_2 = 50;
+const DELAY_STRATEGY_RESPONSE_3 = 100;
+const CALL_ARG_MESSAGE = 0;
+const FIRST_CALL = 0;
 
-const mockServer = require('./retryMock');
-const { rpRetry } = require('../index');
-
-const { expect } = chai;
-chai.should();
-
-// const DEFAULT_NO_MESSAGE = 'no message';
-// const NO_ERROR = 'not an error object';
+should();
+/*
+ * const DEFAULT_NO_MESSAGE = 'no message';
+ * const NO_ERROR = 'not an error object';
+ */
 
 describe('request-retry Unit Tests', () => {
   const correlationId = getCorrelationId('--request-retry-test--');
   // let loggerSpyError;
   let loggerSpyWarn;
   let loggerSpyInfo;
+
   before(() => {
-    mockServer.listen();
+    listen();
   });
 
   describe('rpRetry(options) options validations prerun', () => {
@@ -35,7 +44,7 @@ describe('request-retry Unit Tests', () => {
       retry: {},
     };
     beforeEach(() => {
-      loggerSpyWarn = sinon.spy(logger, 'warn');
+      loggerSpyWarn = spy(logger, 'warn');
     });
     afterEach(() => {
       options.retry = {};
@@ -44,134 +53,134 @@ describe('request-retry Unit Tests', () => {
     it('should not generate warning: null retry, using default', () => {
       options.retry = null;
       return rpRetry(options).then(() => {
-        sinon.assert.notCalled(loggerSpyWarn);
+        assert.notCalled(loggerSpyWarn);
       });
     });
     it('should not generate warning: empty retry, using default', () => rpRetry(options).then(() => {
-      sinon.assert.notCalled(loggerSpyWarn);
+      assert.notCalled(loggerSpyWarn);
     }));
     it('should generate warning: out of scope retries: -1 becoming min', () => {
       options.retry.retries = -1;
       return rpRetry(options).then(() => {
-        sinon.assert.calledOnce(loggerSpyWarn);
-        const callArgs = loggerSpyWarn.getCall(0).args;
-        expect(callArgs[0]).to.be.a('string');
-        expect(callArgs[0]).to.equal('out of scope retries, reset to min');
+        assert.calledOnce(loggerSpyWarn);
+        const callArgs = loggerSpyWarn.getCall(FIRST_CALL).args;
+        expect(callArgs[CALL_ARG_MESSAGE]).to.be.a('string');
+        expect(callArgs[CALL_ARG_MESSAGE]).to.equal('out of scope retries, reset to min');
       });
     });
     it('should generate warning: out of scope retries: 20 becoming max', () => {
       options.retry.retries = 20;
       return rpRetry(options).then(() => {
-        sinon.assert.calledOnce(loggerSpyWarn);
-        const callArgs = loggerSpyWarn.getCall(0).args;
-        expect(callArgs[0]).to.be.a('string');
-        expect(callArgs[0]).to.equal('out of scope retries, reset to max');
+        assert.calledOnce(loggerSpyWarn);
+        const callArgs = loggerSpyWarn.getCall(FIRST_CALL).args;
+        expect(callArgs[CALL_ARG_MESSAGE]).to.be.a('string');
+        expect(callArgs[CALL_ARG_MESSAGE]).to.equal('out of scope retries, reset to max');
       });
     });
     it('should not generate warning: in scope retries', () => {
       options.retry.retries = 10;
       return rpRetry(options).then(() => {
-        sinon.assert.notCalled(loggerSpyWarn);
+        assert.notCalled(loggerSpyWarn);
       });
     });
     it('should generate warning: invalid retries: "notANumber" becoming default', () => {
       options.retry.retries = 'notANumber';
       return rpRetry(options).then(() => {
-        sinon.assert.calledOnce(loggerSpyWarn);
-        const callArgs = loggerSpyWarn.getCall(0).args;
-        expect(callArgs[0]).to.be.a('string');
-        expect(callArgs[0]).to.equal('invalid retries, reset to default');
+        assert.calledOnce(loggerSpyWarn);
+        const callArgs = loggerSpyWarn.getCall(FIRST_CALL).args;
+        expect(callArgs[CALL_ARG_MESSAGE]).to.be.a('string');
+        expect(callArgs[CALL_ARG_MESSAGE]).to.equal('invalid retries, reset to default');
       });
     });
     it('should generate warning: out of scope delay: 0 becoming min', () => {
       options.retry.delay = 0;
       return rpRetry(options).then(() => {
-        sinon.assert.calledOnce(loggerSpyWarn);
-        const callArgs = loggerSpyWarn.getCall(0).args;
-        expect(callArgs[0]).to.be.a('string');
-        expect(callArgs[0]).to.equal('out of scope delay, reset to min');
+        assert.calledOnce(loggerSpyWarn);
+        const callArgs = loggerSpyWarn.getCall(FIRST_CALL).args;
+        expect(callArgs[CALL_ARG_MESSAGE]).to.be.a('string');
+        expect(callArgs[CALL_ARG_MESSAGE]).to.equal('out of scope delay, reset to min');
       });
     });
     it('should generate warning: out of scope delay: 100000 becoming max', () => {
       options.retry.delay = 100000;
       return rpRetry(options).then(() => {
-        sinon.assert.calledOnce(loggerSpyWarn);
-        const callArgs = loggerSpyWarn.getCall(0).args;
-        expect(callArgs[0]).to.be.a('string');
-        expect(callArgs[0]).to.equal('out of scope delay, reset to max');
+        assert.calledOnce(loggerSpyWarn);
+        const callArgs = loggerSpyWarn.getCall(FIRST_CALL).args;
+        expect(callArgs[CALL_ARG_MESSAGE]).to.be.a('string');
+        expect(callArgs[CALL_ARG_MESSAGE]).to.equal('out of scope delay, reset to max');
       });
     });
     it('should generate warning: invalid delay: "notANumber" becoming default', () => {
       options.retry.delay = 'notANumber';
       return rpRetry(options).then(() => {
-        sinon.assert.calledOnce(loggerSpyWarn);
-        const callArgs = loggerSpyWarn.getCall(0).args;
-        expect(callArgs[0]).to.be.a('string');
-        expect(callArgs[0]).to.equal('invalid delay, reset to default');
+        assert.calledOnce(loggerSpyWarn);
+        const callArgs = loggerSpyWarn.getCall(FIRST_CALL).args;
+        expect(callArgs[CALL_ARG_MESSAGE]).to.be.a('string');
+        expect(callArgs[CALL_ARG_MESSAGE]).to.equal('invalid delay, reset to default');
       });
     });
     it('should not generate warning: in scope delay', () => {
       options.retry.delay = 20000;
       return rpRetry(options).then(() => {
-        sinon.assert.notCalled(loggerSpyWarn);
+        assert.notCalled(loggerSpyWarn);
       });
     });
     it('should generate warning: out of scope timeout: 0 becoming min', () => {
       options.retry.timeout = 0;
       return rpRetry(options).then(() => {
-        sinon.assert.calledOnce(loggerSpyWarn);
-        const callArgs = loggerSpyWarn.getCall(0).args;
-        expect(callArgs[0]).to.be.a('string');
-        expect(callArgs[0]).to.equal('out of scope timeout, reset to min');
+        assert.calledOnce(loggerSpyWarn);
+        const callArgs = loggerSpyWarn.getCall(FIRST_CALL).args;
+        expect(callArgs[CALL_ARG_MESSAGE]).to.be.a('string');
+        expect(callArgs[CALL_ARG_MESSAGE]).to.equal('out of scope timeout, reset to min');
       });
     });
     it('should generate warning: out of scope timeout: 150  becoming max', () => {
       options.retry.timeout = 150;
       return rpRetry(options).then(() => {
-        sinon.assert.calledOnce(loggerSpyWarn);
-        const callArgs = loggerSpyWarn.getCall(0).args;
-        expect(callArgs[0]).to.be.a('string');
-        expect(callArgs[0]).to.equal('out of scope timeout, reset to max');
+        assert.calledOnce(loggerSpyWarn);
+        const callArgs = loggerSpyWarn.getCall(FIRST_CALL).args;
+        expect(callArgs[CALL_ARG_MESSAGE]).to.be.a('string');
+        expect(callArgs[CALL_ARG_MESSAGE]).to.equal('out of scope timeout, reset to max');
       });
     });
     it('should generate warning: invalid timeout: "notANumber" becoming default', () => {
       options.retry.timeout = 'notANumber';
       return rpRetry(options).then(() => {
-        sinon.assert.calledOnce(loggerSpyWarn);
-        const callArgs = loggerSpyWarn.getCall(0).args;
-        expect(callArgs[0]).to.be.a('string');
-        expect(callArgs[0]).to.equal('invalid timeout, reset to default');
+        assert.calledOnce(loggerSpyWarn);
+        const callArgs = loggerSpyWarn.getCall(FIRST_CALL).args;
+        expect(callArgs[CALL_ARG_MESSAGE]).to.be.a('string');
+        expect(callArgs[CALL_ARG_MESSAGE]).to.equal('invalid timeout, reset to default');
       });
     });
     it('should not generate warning: in scope timeout', () => {
       options.retry.timeout = 50;
       return rpRetry(options).then(() => {
-        sinon.assert.notCalled(loggerSpyWarn);
+        assert.notCalled(loggerSpyWarn);
       });
     });
     it('should generate warning: invalid retryStrategy: "notANumber" becoming default function', () => {
       options.retry.retryStrategy = 'notAFunction';
       return rpRetry(options).then(() => {
-        sinon.assert.calledOnce(loggerSpyWarn);
-        const callArgs = loggerSpyWarn.getCall(0).args;
-        expect(callArgs[0]).to.be.a('string');
-        expect(callArgs[0]).to.equal('invalid retryStrategy, ignoring');
+        assert.calledOnce(loggerSpyWarn);
+        const callArgs = loggerSpyWarn.getCall(FIRST_CALL).args;
+        expect(callArgs[CALL_ARG_MESSAGE]).to.be.a('string');
+        expect(callArgs[CALL_ARG_MESSAGE]).to.equal('invalid retryStrategy, ignoring');
       });
     });
     it('should generate warning: invalid delayStrategy: "notANumber" becoming delay or default', () => {
       options.retry.delayStrategy = 'notAFunction';
       return rpRetry(options).then(() => {
-        sinon.assert.calledOnce(loggerSpyWarn);
-        const callArgs = loggerSpyWarn.getCall(0).args;
-        expect(callArgs[0]).to.be.a('string');
-        expect(callArgs[0]).to.equal('invalid delayStrategy, using delay');
+        assert.calledOnce(loggerSpyWarn);
+        const callArgs = loggerSpyWarn.getCall(FIRST_CALL).args;
+        expect(callArgs[CALL_ARG_MESSAGE]).to.be.a('string');
+        expect(callArgs[CALL_ARG_MESSAGE]).to.equal('invalid delayStrategy, using delay');
       });
     });
     it('should generate multiple warnings', () => {
       options.retry.delayStrategy = 'notAFunction';
       options.retry.retries = 'notANumber';
       return rpRetry(options).then(() => {
-        sinon.assert.calledTwice(loggerSpyWarn);
+        assert.calledTwice(loggerSpyWarn);
       });
     });
     it('should generate warning: invalid logLevel.request, reset to default', () => {
@@ -179,20 +188,20 @@ describe('request-retry Unit Tests', () => {
         request: 'unknownLevel',
       };
       return rpRetry(options).then(() => {
-        sinon.assert.calledOnce(loggerSpyWarn);
-        const callArgs = loggerSpyWarn.getCall(0).args;
-        expect(callArgs[0]).to.be.a('string');
-        expect(callArgs[0]).to.equal('invalid logLevel.request, reset to default');
+        assert.calledOnce(loggerSpyWarn);
+        const callArgs = loggerSpyWarn.getCall(FIRST_CALL).args;
+        expect(callArgs[CALL_ARG_MESSAGE]).to.be.a('string');
+        expect(callArgs[CALL_ARG_MESSAGE]).to.equal('invalid logLevel.request, reset to default');
       });
     });
     it('should not generate warning: correct logLevel (info)', () => {
-      loggerSpyInfo = sinon.spy(logger, 'info');
+      loggerSpyInfo = spy(logger, 'info');
       options.retry.logLevel = {
         response: 'info',
       };
       return rpRetry(options).then(() => {
-        sinon.assert.notCalled(loggerSpyWarn);
-        sinon.assert.calledOnce(loggerSpyInfo);
+        assert.notCalled(loggerSpyWarn);
+        assert.calledOnce(loggerSpyInfo);
         loggerSpyInfo.restore();
       });
     });
@@ -201,10 +210,10 @@ describe('request-retry Unit Tests', () => {
         responseDetails: 'unknownDetails',
       };
       return rpRetry(options).then(() => {
-        sinon.assert.calledOnce(loggerSpyWarn);
-        const callArgs = loggerSpyWarn.getCall(0).args;
-        expect(callArgs[0]).to.be.a('string');
-        expect(callArgs[0]).to.equal('invalid logLevel.responseDetails, reset to default');
+        assert.calledOnce(loggerSpyWarn);
+        const callArgs = loggerSpyWarn.getCall(FIRST_CALL).args;
+        expect(callArgs[CALL_ARG_MESSAGE]).to.be.a('string');
+        expect(callArgs[CALL_ARG_MESSAGE]).to.equal('invalid logLevel.responseDetails, reset to default');
       });
     });
     it('should not generate warning: correct logLevelResponseName', () => {
@@ -212,7 +221,7 @@ describe('request-retry Unit Tests', () => {
         responseName: 'aName',
       };
       return rpRetry(options).then(() => {
-        sinon.assert.notCalled(loggerSpyWarn);
+        assert.notCalled(loggerSpyWarn);
       });
     });
     it('should generate warning: invalid logLevel.responseName (""), reset to default', () => {
@@ -220,10 +229,10 @@ describe('request-retry Unit Tests', () => {
         responseName: '',
       };
       return rpRetry(options).then(() => {
-        sinon.assert.calledOnce(loggerSpyWarn);
-        const callArgs = loggerSpyWarn.getCall(0).args;
-        expect(callArgs[0]).to.be.a('string');
-        expect(callArgs[0]).to.equal('invalid logLevel.responseName, reset to default');
+        assert.calledOnce(loggerSpyWarn);
+        const callArgs = loggerSpyWarn.getCall(FIRST_CALL).args;
+        expect(callArgs[CALL_ARG_MESSAGE]).to.be.a('string');
+        expect(callArgs[CALL_ARG_MESSAGE]).to.equal('invalid logLevel.responseName, reset to default');
       });
     });
     it('should generate warning: invalid logLevel.responseName ("    ""), reset to default', () => {
@@ -231,15 +240,15 @@ describe('request-retry Unit Tests', () => {
         responseName: '    ',
       };
       return rpRetry(options).then(() => {
-        sinon.assert.calledOnce(loggerSpyWarn);
-        const callArgs = loggerSpyWarn.getCall(0).args;
-        expect(callArgs[0]).to.be.a('string');
-        expect(callArgs[0]).to.equal('invalid logLevel.responseName, reset to default');
+        assert.calledOnce(loggerSpyWarn);
+        const callArgs = loggerSpyWarn.getCall(FIRST_CALL).args;
+        expect(callArgs[CALL_ARG_MESSAGE]).to.be.a('string');
+        expect(callArgs[CALL_ARG_MESSAGE]).to.equal('invalid logLevel.responseName, reset to default');
       });
     });
   });
-  describe('rpRetry(options) options validation run', function test() {
-    this.timeout(50000);
+  describe('rpRetry(options) options validation run', function Test() {
+    this.timeout(TIMEOUT);
     const options = {
       method: 'GET',
       headers: {
@@ -250,21 +259,23 @@ describe('request-retry Unit Tests', () => {
       retry: {},
     };
     beforeEach(() => {
-      loggerSpyWarn = sinon.spy(logger, 'warn');
+      loggerSpyWarn = spy(logger, 'warn');
     });
     afterEach(() => {
       options.retry = {};
       loggerSpyWarn.restore();
     });
     it('should generate warning: bad retry strategy (throwing an error), ignoring and using default retries', () => {
-      options.retry.retryStrategy = () => { throw new Error('this is a test'); };
+      options.retry.retryStrategy = () => {
+        throw new Error('this is a test');
+      };
       options.retry.retries = 2;
       return rpRetry(options)
         .catch(() => {
-          sinon.assert.called(loggerSpyWarn);
-          const callArgs = loggerSpyWarn.getCall(0).args;
-          expect(callArgs[0]).to.be.a('string');
-          expect(callArgs[0]).to.equal('bad retry strategy');
+          assert.called(loggerSpyWarn);
+          const callArgs = loggerSpyWarn.getCall(FIRST_CALL).args;
+          expect(callArgs[CALL_ARG_MESSAGE]).to.be.a('string');
+          expect(callArgs[CALL_ARG_MESSAGE]).to.equal('bad retry strategy');
         });
     });
     it('should generate warning: bad retry strategy (not returning a boolean), ignoring and using default retries', () => {
@@ -272,10 +283,10 @@ describe('request-retry Unit Tests', () => {
       options.retry.retries = 2;
       return rpRetry(options)
         .catch(() => {
-          sinon.assert.called(loggerSpyWarn);
-          const callArgs = loggerSpyWarn.getCall(0).args;
-          expect(callArgs[0]).to.be.a('string');
-          expect(callArgs[0]).to.equal('bad retry strategy');
+          assert.called(loggerSpyWarn);
+          const callArgs = loggerSpyWarn.getCall(FIRST_CALL).args;
+          expect(callArgs[CALL_ARG_MESSAGE]).to.be.a('string');
+          expect(callArgs[CALL_ARG_MESSAGE]).to.equal('bad retry strategy');
         });
     });
     it('should not generate warning: retry strategy returning a boolean', () => {
@@ -283,18 +294,20 @@ describe('request-retry Unit Tests', () => {
       options.retry.retries = 2;
       return rpRetry(options)
         .catch(() => {
-          sinon.assert.called(loggerSpyWarn);
+          assert.called(loggerSpyWarn);
         });
     });
     it('should generate warning: bad delay strategy (throwing an error), ignoring and using default delay', () => {
-      options.retry.delayStrategy = () => { throw new Error('this is a test'); };
+      options.retry.delayStrategy = () => {
+        throw new Error('this is a test');
+      };
       options.retry.retries = 2;
       return rpRetry(options)
         .catch(() => {
-          sinon.assert.called(loggerSpyWarn);
-          const callArgs = loggerSpyWarn.getCall(0).args;
-          expect(callArgs[0]).to.be.a('string');
-          expect(callArgs[0]).to.equal('bad delay strategy');
+          assert.called(loggerSpyWarn);
+          const callArgs = loggerSpyWarn.getCall(FIRST_CALL).args;
+          expect(callArgs[CALL_ARG_MESSAGE]).to.be.a('string');
+          expect(callArgs[CALL_ARG_MESSAGE]).to.equal('bad delay strategy');
         });
     });
     it('should generate warning: bad delay strategy (not returning a number), ignoring and using default delay', () => {
@@ -302,40 +315,40 @@ describe('request-retry Unit Tests', () => {
       options.retry.retries = 2;
       return rpRetry(options)
         .catch(() => {
-          sinon.assert.called(loggerSpyWarn);
-          const callArgs = loggerSpyWarn.getCall(0).args;
-          expect(callArgs[0]).to.be.a('string');
-          expect(callArgs[0]).to.equal('bad delay strategy');
+          assert.called(loggerSpyWarn);
+          const callArgs = loggerSpyWarn.getCall(FIRST_CALL).args;
+          expect(callArgs[CALL_ARG_MESSAGE]).to.be.a('string');
+          expect(callArgs[CALL_ARG_MESSAGE]).to.equal('bad delay strategy');
         });
     });
     it('should generate warning: bad delay strategy (returning an out of scope number), ignoring and using default delay', () => {
-      options.retry.delayStrategy = () => -20;
+      options.retry.delayStrategy = () => DELAY_STRATEGY_RESPONSE_1;
       options.retry.retries = 2;
       return rpRetry(options)
         .catch(() => {
-          sinon.assert.called(loggerSpyWarn);
-          const callArgs = loggerSpyWarn.getCall(0).args;
-          expect(callArgs[0]).to.be.a('string');
-          expect(callArgs[0]).to.equal('calculated delay out of scope: using delay or default');
+          assert.called(loggerSpyWarn);
+          const callArgs = loggerSpyWarn.getCall(FIRST_CALL).args;
+          expect(callArgs[CALL_ARG_MESSAGE]).to.be.a('string');
+          expect(callArgs[CALL_ARG_MESSAGE]).to.equal('calculated delay out of scope: using delay or default');
         });
     });
     it('should not generate warning: delay strategy returning an in scope number', () => {
-      options.retry.delayStrategy = () => 50;
+      options.retry.delayStrategy = () => DELAY_STRATEGY_RESPONSE_2;
       options.retry.retries = 2;
       return rpRetry(options)
         .catch(() => {
-          sinon.assert.called(loggerSpyWarn);
+          assert.called(loggerSpyWarn);
         });
     });
     it('should generate a timeout error', () => {
-      options.retry.delayStrategy = () => 10000;
-      options.retry.timeout = 10;
-      options.retry.retries = 2;
+      options.retry.delayStrategy = () => RETRY_DELAY;
+      options.retry.timeout = RETRY_TIMEOUT;
+      options.retry.retries = RETRY_RETRIES;
       return rpRetry(options)
         .catch((err) => {
           expect(err.name).to.equal('System');
           expect(err.cause.name).to.equal('TimeoutError');
-          // sinon.assert.called(loggerSpyWarn);
+          // assert.called(loggerSpyWarn);
         });
     });
     it('should stop mock server', () => rpRetry({
@@ -345,7 +358,7 @@ describe('request-retry Unit Tests', () => {
       },
       url: 'http://localhost:9070/stop',
       retry: {
-        delayStrategy: () => 100,
+        delayStrategy: () => DELAY_STRATEGY_RESPONSE_3,
         retries: 1,
       },
     })

package/test/testEnv.js

@@ -1,4 +1,5 @@
 /* eslint no-process-env: "off" */
+import process from 'process';
 
 /**
  * The following environment variables are set for the test:
@@ -13,8 +14,10 @@
  * | LOG_MODE | log mode | none
  */
 
-// process.env.SUMO_LOGIC_ENDPOINT = 'http://localhost:9080/logs/';
-// process.env.SUMO_LOGIC_COLLECTOR_CODE = '1234';
+/*
+ * process.env.SUMO_LOGIC_ENDPOINT = 'http://localhost:9080/logs/';
+ * process.env.SUMO_LOGIC_COLLECTOR_CODE = '1234';
+ */
 process.env.SUMO_LOGIC_ENDPOINT = null;
 process.env.SUMO_LOGIC_COLLECTOR_CODE = null;
 process.env.NO_STACK = 'yes';

package/.eslintrc

@@ -1,43 +0,0 @@
-{
-  "plugins": [
-    "@mimik/document-env",
-    "@mimik/dependencies"
-  ],
-  "env": {
-    "node": true
-  },
-  "parserOptions": {
-    "ecmaVersion": 2020
-  },
-  "extends": "airbnb",
-  "rules": {
-    "import/no-extraneous-dependencies": ["error", {"devDependencies": true}],
-    "import/no-unresolved": ["error", { "amd": true, "commonjs": true, "caseSensitiveStrict": true }],
-    "brace-style": [1, "stroustrup", {"allowSingleLine": true}],
-    "no-confusing-arrow": [0], // arrow isnt confusing
-    "max-len": [1, 180, { "ignoreComments": true }],
-    "linebreak-style": 0,
-    "quotes": [1, "single"],
-    "semi": [1, "always"],
-    "no-process-env": ["error"],
-    "@mimik/document-env/validate-document-env": 2,
-    "@mimik/dependencies/case-sensitive": 2,
-    "@mimik/dependencies/no-cycles": 2,
-    "@mimik/dependencies/require-json-ext": 2
-  },
-  "settings":{
-    "react": {
-      "version": "detect"
-    }
-  },
-  "globals": {
-    "module": true,
-    "require": true,
-    "const": false,
-    "it": false,
-    "describe": false,
-    "before": true,
-    "after": true,
-    "JSON": true
-  }
-}