Add fetch content timeout parameters

Author: Nikos Vasileiou

packages/native/README.md

@@ -153,6 +153,14 @@ tx.init({
 
   // Translation cache, defaults to "new MemoryCache()"
   cache: Function,
+
+  // Optional timeout in milliseconds when fetching languages and
+  // strings, defaults to 0 (no-timeout)
+  fetchTimeout: Number,
+
+  // Optional interval polling delay in milliseconds while waiting
+  // for CDS to warm-up with content, defaults to 250msec
+  fetchInterval: Number,
 })
 ```
 

packages/native/src/TxNative.js

@@ -30,6 +30,8 @@ export default class TxNative {
     this.token = '';
     this.secret = '';
     this.filterTags = '';
+    this.fetchTimeout = 0;
+    this.fetchInterval = 250;
     this.cache = new MemoryCache();
     this.missingPolicy = new SourceStringPolicy();
     this.errorPolicy = new SourceErrorPolicy();
@@ -48,6 +50,8 @@ export default class TxNative {
    * @param {String} params.filterTags
    * @param {String} params.token
    * @param {String} params.secret
+   * @param {Number} params.fetchTimeout
+   * @param {Number} params.fetchInterval
    * @param {Function} params.cache
    * @param {Function} params.missingPolicy
    * @param {Function} params.errorPolicy
@@ -61,6 +65,8 @@ export default class TxNative {
       'secret',
       'cache',
       'filterTags',
+      'fetchTimeout',
+      'fetchInterval',
       'missingPolicy',
       'errorPolicy',
       'stringRenderer',
@@ -183,11 +189,17 @@ export default class TxNative {
       }
     }
 
+    const handleError = (err) => {
+      sendEvent(TRANSLATIONS_FETCH_FAILED, { localeCode, filterTags }, this);
+      return err;
+    };
+
     // contact CDS
     try {
       sendEvent(FETCHING_TRANSLATIONS, { localeCode, filterTags }, this);
       let response;
       let lastResponseStatus = 202;
+      const tsNow = Date.now();
       while (lastResponseStatus === 202) {
         /* eslint-disable no-await-in-loop */
         let url = `${this.cdsHost}/content/${localeCode}`;
@@ -201,8 +213,14 @@ export default class TxNative {
             'X-NATIVE-SDK': `txjs/${__PLATFORM__}/${__VERSION__}`,
           },
         });
-        /* eslint-enable no-await-in-loop */
         lastResponseStatus = response.status;
+        if (this.fetchTimeout > 0 && (Date.now() - tsNow) >= this.fetchTimeout) {
+          throw handleError(new Error('Fetch translations timeout'));
+        }
+        if (lastResponseStatus === 202 && this.fetchInterval > 0) {
+          await sleep(this.fetchInterval);
+        }
+        /* eslint-enable no-await-in-loop */
       }
 
       const { data } = response;
@@ -216,12 +234,10 @@ export default class TxNative {
         this.cache.update(localeCode, hashmap);
         sendEvent(TRANSLATIONS_FETCHED, { localeCode, filterTags }, this);
       } else {
-        sendEvent(TRANSLATIONS_FETCH_FAILED, { localeCode, filterTags }, this);
-        throw new Error('Could not fetch translations');
+        throw handleError(new Error('Could not fetch translations'));
       }
     } catch (err) {
-      sendEvent(TRANSLATIONS_FETCH_FAILED, { localeCode, filterTags }, this);
-      throw err;
+      throw handleError(err);
     }
   }
 
@@ -355,11 +371,17 @@ export default class TxNative {
 
     if (!this.token) return [];
 
+    const handleError = (err) => {
+      sendEvent(LOCALES_FETCH_FAILED, null, this);
+      return err;
+    };
+
     // contact CDS
     try {
       sendEvent(FETCHING_LOCALES, null, this);
       let response;
       let lastResponseStatus = 202;
+      const tsNow = Date.now();
       while (lastResponseStatus === 202) {
         /* eslint-disable no-await-in-loop */
         response = await axios.get(`${this.cdsHost}/languages`, {
@@ -369,8 +391,14 @@ export default class TxNative {
             'X-NATIVE-SDK': `txjs/${__PLATFORM__}/${__VERSION__}`,
           },
         });
-        /* eslint-enable no-await-in-loop */
         lastResponseStatus = response.status;
+        if (this.fetchTimeout > 0 && (Date.now() - tsNow) >= this.fetchTimeout) {
+          throw handleError(new Error('Get locales timeout'));
+        }
+        if (lastResponseStatus === 202 && this.fetchInterval > 0) {
+          await sleep(this.fetchInterval);
+        }
+        /* eslint-enable no-await-in-loop */
       }
 
       const { data } = response;
@@ -379,12 +407,10 @@ export default class TxNative {
         this.locales = this.languages.map((entry) => entry.code);
         sendEvent(LOCALES_FETCHED, null, this);
       } else {
-        sendEvent(LOCALES_FETCH_FAILED, null, this);
-        throw new Error('Could not fetch languages');
+        throw handleError(new Error('Could not fetch languages'));
       }
     } catch (err) {
-      sendEvent(LOCALES_FETCH_FAILED, null, this);
-      throw err;
+      throw handleError(err);
     }
 
     return [...this.locales];

packages/native/tests/tx.test.js

@@ -1,10 +1,24 @@
-/* globals describe, it */
+/* globals describe, it, beforeEach, afterEach */
 
 import { expect } from 'chai';
 import nock from 'nock';
 import { tx, t, generateKey } from '../src/index';
 
 describe('tx instance', () => {
+  let fetchTimeout;
+  let fetchInterval;
+
+  beforeEach(() => {
+    fetchTimeout = tx.fetchTimeout;
+    fetchInterval = tx.fetchInterval;
+    tx.init({ fetchTimeout: 0, fetchInterval: 0 });
+  });
+
+  afterEach(() => {
+    nock.cleanAll();
+    tx.init({ fetchTimeout, fetchInterval });
+  });
+
   it('getLocales fetches locales', async () => {
     tx.init({
       token: 'abcd',
@@ -216,6 +230,51 @@ describe('tx instance', () => {
     expect(locales).to.deep.equal(['el']);
   });
 
+  it('retries fetching languages with timeout', async () => {
+    tx.init({ token: 'abcd', fetchTimeout: 50 });
+    nock(tx.cdsHost)
+      .get('/languages')
+      .delayConnection(60)
+      .reply(202)
+      .get('/languages')
+      .reply(200, {
+        data: [{
+          name: 'Greek',
+          code: 'el',
+          localized_name: 'Ελληνικά',
+          rtl: false,
+        }],
+      });
+
+    let error;
+    try {
+      await tx.getLocales({ refresh: true });
+    } catch (err) {
+      error = err;
+    }
+    expect(error.message).to.equal('Get locales timeout');
+  });
+
+  it('retries fetching languages with interval', async () => {
+    tx.init({ token: 'abcd', fetchInterval: 50 });
+    nock(tx.cdsHost)
+      .get('/languages')
+      .reply(202)
+      .get('/languages')
+      .reply(200, {
+        data: [{
+          name: 'Greek',
+          code: 'el',
+          localized_name: 'Ελληνικά',
+          rtl: false,
+        }],
+      });
+
+    const ts = Date.now();
+    await tx.getLocales({ refresh: true });
+    expect(Date.now() - ts).to.be.greaterThan(50);
+  });
+
   it('retries fetching translations', async () => {
     tx.init({ token: 'abcd' });
     nock(tx.cdsHost)
@@ -227,4 +286,35 @@ describe('tx instance', () => {
     await tx.fetchTranslations('el');
     expect(tx.cache.get('source', 'el')).to.equal('translation');
   });
+
+  it('retries fetching translations with timeout', async () => {
+    tx.init({ token: 'abcd', fetchTimeout: 50 });
+    nock(tx.cdsHost)
+      .get('/content/el_timeout')
+      .delayConnection(60)
+      .reply(202)
+      .get('/content/el_timeout')
+      .reply(200, { data: { source: { string: 'translation' } } });
+
+    let error;
+    try {
+      await tx.fetchTranslations('el_timeout');
+    } catch (err) {
+      error = err;
+    }
+    expect(error.message).to.equal('Fetch translations timeout');
+  });
+
+  it('retries fetching translations with interval delays', async () => {
+    tx.init({ token: 'abcd', fetchInterval: 50 });
+    nock(tx.cdsHost)
+      .get('/content/el_interval')
+      .reply(202)
+      .get('/content/el_interval')
+      .reply(200, { data: { source: { string: 'translation' } } });
+
+    const ts = Date.now();
+    await tx.fetchTranslations('el_interval');
+    expect(Date.now() - ts).to.be.greaterThan(50);
+  });
 });