@splitsoftware/splitio-commons 2.4.2-rc.1 → 2.4.2-rc.2

package/esm/sync/syncManagerOnline.js

@@ -4,6 +4,7 @@ import { SYNC_START_POLLING, SYNC_CONTINUE_POLLING, SYNC_STOP_POLLING } from '..
 import { isConsentGranted } from '../consent';
 import { POLLING, STREAMING, SYNC_MODE_UPDATE } from '../utils/constants';
 import { SDK_SPLITS_CACHE_LOADED } from '../readiness/constants';
+import { usesSegmentsSync } from '../storages/AbstractSplitsCacheSync';
 /**
  * Online SyncManager factory.
  * Can be used for server-side API, and client-side API with or without multiple clients.
@@ -65,35 +66,39 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
              */
             start: function () {
                 running = true;
-                if (startFirstTime) {
-                    var isCacheLoaded = storage.validateCache ? storage.validateCache() : false;
-                    if (isCacheLoaded)
-                        Promise.resolve().then(function () { readiness.splits.emit(SDK_SPLITS_CACHE_LOADED); });
-                }
-                // start syncing splits and segments
-                if (pollingManager) {
-                    // If synchronization is disabled pushManager and pollingManager should not start
-                    if (syncEnabled) {
-                        if (pushManager) {
-                            // Doesn't call `syncAll` when the syncManager is resuming
-                            if (startFirstTime) {
-                                pollingManager.syncAll();
+                // @TODO once event, impression and telemetry storages support persistence, call when `validateCache` promise is resolved
+                submitterManager.start(!isConsentGranted(settings));
+                return Promise.resolve(storage.validateCache ? storage.validateCache() : false).then(function (isCacheLoaded) {
+                    if (!running)
+                        return;
+                    if (startFirstTime) {
+                        // Emits SDK_READY_FROM_CACHE
+                        if (isCacheLoaded)
+                            readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
+                    }
+                    // start syncing splits and segments
+                    if (pollingManager) {
+                        // If synchronization is disabled pushManager and pollingManager should not start
+                        if (syncEnabled) {
+                            if (pushManager) {
+                                // Doesn't call `syncAll` when the syncManager is resuming
+                                if (startFirstTime) {
+                                    pollingManager.syncAll();
+                                }
+                                pushManager.start();
+                            }
+                            else {
+                                pollingManager.start();
                             }
-                            pushManager.start();
                         }
                         else {
-                            pollingManager.start();
-                        }
-                    }
-                    else {
-                        if (startFirstTime) {
-                            pollingManager.syncAll();
+                            if (startFirstTime) {
+                                pollingManager.syncAll();
+                            }
                         }
                     }
-                }
-                // start periodic data recording (events, impressions, telemetry).
-                submitterManager.start(!isConsentGranted(settings));
-                startFirstTime = false;
+                    startFirstTime = false;
+                });
             },
             /**
              * Method used to stop/pause the syncManager.
@@ -127,7 +132,7 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
                         if (pushManager) {
                             if (pollingManager.isRunning()) {
                                 // if doing polling, we must start the periodic fetch of data
-                                if (storage.splits.usesSegments() || storage.rbSegments.usesSegments())
+                                if (usesSegmentsSync(storage))
                                     mySegmentsSyncTask.start();
                             }
                             else {
@@ -137,7 +142,7 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
                             }
                         }
                         else {
-                            if (storage.splits.usesSegments() || storage.rbSegments.usesSegments())
+                            if (usesSegmentsSync(storage))
                                 mySegmentsSyncTask.start();
                         }
                     }

package/esm/trackers/impressionsTracker.js

@@ -6,7 +6,7 @@ import { CONSENT_DECLINED, DEDUPED, QUEUED } from '../utils/constants';
  * Impressions tracker stores impressions in cache and pass them to the listener and integrations manager if provided.
  */
 export function impressionsTrackerFactory(settings, impressionsCache, noneStrategy, strategy, whenInit, integrationsManager, telemetryCache) {
-    var log = settings.log, _a = settings.runtime, ip = _a.ip, hostname = _a.hostname, version = settings.version;
+    var log = settings.log, impressionListener = settings.impressionListener, _a = settings.runtime, ip = _a.ip, hostname = _a.hostname, version = settings.version;
     return {
         track: function (impressions, attributes) {
             if (settings.userConsent === CONSENT_DECLINED)
@@ -39,7 +39,7 @@ export function impressionsTrackerFactory(settings, impressionsCache, noneStrate
                 }
             }
             // @TODO next block might be handled by the integration manager. In that case, the metadata object doesn't need to be passed in the constructor
-            if (settings.impressionListener || integrationsManager) {
+            if (impressionListener || integrationsManager) {
                 var _loop_1 = function (i) {
                     var impressionData = {
                         // copy of impression, to avoid unexpected behavior if modified by integrations or impressionListener
@@ -56,8 +56,8 @@ export function impressionsTrackerFactory(settings, impressionsCache, noneStrate
                             if (integrationsManager)
                                 integrationsManager.handleImpression(impressionData);
                             try { // @ts-ignore. An exception on the listeners should not break the SDK.
-                                if (settings.impressionListener)
-                                    settings.impressionListener.logImpression(impressionData);
+                                if (impressionListener)
+                                    impressionListener.logImpression(impressionData);
                             }
                             catch (err) {
                                 log.error(ERROR_IMPRESSIONS_LISTENER, [err]);

package/esm/utils/env/isLocalStorageAvailable.js

@@ -1,12 +1,33 @@
-/* eslint-disable no-undef */
 export function isLocalStorageAvailable() {
+    try {
+        // eslint-disable-next-line no-undef
+        return isValidStorageWrapper(localStorage);
+    }
+    catch (e) {
+        return false;
+    }
+}
+export function isValidStorageWrapper(wrapper) {
     var mod = '__SPLITSOFTWARE__';
     try {
-        localStorage.setItem(mod, mod);
-        localStorage.removeItem(mod);
+        wrapper.setItem(mod, mod);
+        wrapper.getItem(mod);
+        wrapper.removeItem(mod);
         return true;
     }
     catch (e) {
         return false;
     }
 }
+export function isWebStorage(wrapper) {
+    if (typeof wrapper.length === 'number') {
+        try {
+            wrapper.key(0);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    return false;
+}

package/esm/utils/settingsValidation/splitFilters.js

@@ -58,12 +58,6 @@ function validateSplitFilter(log, type, values, maxLength) {
 /**
  * Returns a string representing the URL encoded query component of /splitChanges URL.
  *
- * The possible formats of the query string are:
- *  - null: if all filters are empty
- *  - '&names=<comma-separated-values>': if only `byPrefix` filter is undefined
- *  - '&prefixes=<comma-separated-values>': if only `byName` filter is undefined
- *  - '&names=<comma-separated-values>&prefixes=<comma-separated-values>': if no one is undefined
- *
  * @param groupedFilters - object of filters. Each filter must be a list of valid, unique and ordered string values.
  * @returns null or string with the `split filter query` component of the URL.
  */

package/esm/utils/settingsValidation/storage/storageCS.js

@@ -3,7 +3,7 @@ import { ERROR_STORAGE_INVALID } from '../../../logger/constants';
 import { LOCALHOST_MODE, STANDALONE_MODE, STORAGE_PLUGGABLE, STORAGE_LOCALSTORAGE, STORAGE_MEMORY } from '../../../utils/constants';
 export function __InLocalStorageMockFactory(params) {
     var result = InMemoryStorageCSFactory(params);
-    result.validateCache = function () { return true; }; // to emit SDK_READY_FROM_CACHE
+    result.validateCache = function () { return Promise.resolve(true); }; // to emit SDK_READY_FROM_CACHE
     return result;
 }
 __InLocalStorageMockFactory.type = STORAGE_MEMORY;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "2.4.2-rc.1",
+  "version": "2.4.2-rc.2",
   "description": "Split JavaScript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package/src/logger/messages/error.ts

@@ -14,7 +14,7 @@ export const codesError: [number, string][] = [
   [c.ERROR_SYNC_OFFLINE_LOADING, c.LOG_PREFIX_SYNC_OFFLINE + 'There was an issue loading the mock feature flags data. No changes will be applied to the current cache. %s'],
   [c.ERROR_STREAMING_SSE, c.LOG_PREFIX_SYNC_STREAMING + 'Failed to connect or error on streaming connection, with error message: %s'],
   [c.ERROR_STREAMING_AUTH, c.LOG_PREFIX_SYNC_STREAMING + 'Failed to authenticate for streaming. Error: %s.'],
-  [c.ERROR_HTTP, 'Response status is not OK. Status: %s. URL: %s. Message: %s'],
+  [c.ERROR_HTTP, 'HTTP request failed with %s. URL: %s. Message: %s'],
   // client status
   [c.ERROR_CLIENT_LISTENER, 'A listener was added for %s on the SDK, which has already fired and won\'t be emitted again. The callback won\'t be executed.'],
   [c.ERROR_CLIENT_DESTROYED, '%s: Client has already been destroyed - no calls possible.'],

package/src/sdkClient/sdkClient.ts

@@ -48,7 +48,6 @@ export function sdkClientFactory(params: ISdkFactoryContext, isSharedClient?: bo
 
     // Sdk destroy
     {
-      __ctx: params,
       flush() {
         // @TODO define cooldown time
         return __cooldown(__flush, COOLDOWN_TIME_IN_MILLIS);

package/src/sdkFactory/index.ts

@@ -107,7 +107,8 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ISDK | SplitIO.IA
 
   log.info(NEW_FACTORY);
 
-  const factory = objectAssign({
+  // @ts-ignore
+  return objectAssign({
     // Split evaluation and event tracking engine
     client: clientMethod,
 
@@ -125,17 +126,6 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ISDK | SplitIO.IA
     destroy() {
       hasInit = false;
       return Promise.all(Object.keys(clients).map(key => clients[key].destroy())).then(() => { });
-    },
-
-    __ctx: ctx
+    }
   }, extraProps && extraProps(ctx), lazyInit ? { init } : init());
-
-  // append factory to global
-  if (typeof window === 'object') { // @ts-ignore
-    // eslint-disable-next-line no-undef
-    (window.__HARNESS_FME__ = window.__HARNESS_FME__ || []).push(factory);
-  }
-
-  // @ts-ignore
-  return factory;
 }

package/src/services/splitHttpClient.ts

@@ -70,7 +70,7 @@ export function splitHttpClientFactory(settings: ISettings, { getOptions, getFet
         }
 
         if (!resp || resp.status !== 403) { // 403's log we'll be handled somewhere else.
-          log[logErrorsAsInfo ? 'info' : 'error'](ERROR_HTTP, [resp ? resp.status : 'NO_STATUS', url, msg]);
+          log[logErrorsAsInfo ? 'info' : 'error'](ERROR_HTTP, [resp ? 'status code ' + resp.status : 'no status code', url, msg]);
         }
 
         const networkError: NetworkError = new Error(msg);

package/src/storages/AbstractMySegmentsCacheSync.ts

@@ -49,12 +49,10 @@ export abstract class AbstractMySegmentsCacheSync implements ISegmentsCacheSync
    * For client-side synchronizer: it resets or updates the cache.
    */
   resetSegments(segmentsData: MySegmentsData | IMySegmentsResponse): boolean {
-    this.setChangeNumber(segmentsData.cn);
-
     const { added, removed } = segmentsData as MySegmentsData;
+    let isDiff = false;
 
     if (added && removed) {
-      let isDiff = false;
 
       added.forEach(segment => {
         isDiff = this.addSegment(segment) || isDiff;
@@ -63,32 +61,40 @@ export abstract class AbstractMySegmentsCacheSync implements ISegmentsCacheSync
       removed.forEach(segment => {
         isDiff = this.removeSegment(segment) || isDiff;
       });
+    } else {
 
-      return isDiff;
-    }
+      const names = ((segmentsData as IMySegmentsResponse).k || []).map(s => s.n).sort();
+      const storedSegmentKeys = this.getRegisteredSegments().sort();
 
-    const names = ((segmentsData as IMySegmentsResponse).k || []).map(s => s.n).sort();
-    const storedSegmentKeys = this.getRegisteredSegments().sort();
+      // Extreme fast => everything is empty
+      if (!names.length && !storedSegmentKeys.length) {
+        isDiff = false;
+      } else {
 
-    // Extreme fast => everything is empty
-    if (!names.length && !storedSegmentKeys.length) return false;
+        let index = 0;
 
-    let index = 0;
+        while (index < names.length && index < storedSegmentKeys.length && names[index] === storedSegmentKeys[index]) index++;
 
-    while (index < names.length && index < storedSegmentKeys.length && names[index] === storedSegmentKeys[index]) index++;
+        // Quick path => no changes
+        if (index === names.length && index === storedSegmentKeys.length) {
+          isDiff = false;
+        } else {
 
-    // Quick path => no changes
-    if (index === names.length && index === storedSegmentKeys.length) return false;
+          // Slowest path => add and/or remove segments
+          for (let removeIndex = index; removeIndex < storedSegmentKeys.length; removeIndex++) {
+            this.removeSegment(storedSegmentKeys[removeIndex]);
+          }
 
-    // Slowest path => add and/or remove segments
-    for (let removeIndex = index; removeIndex < storedSegmentKeys.length; removeIndex++) {
-      this.removeSegment(storedSegmentKeys[removeIndex]);
-    }
+          for (let addIndex = index; addIndex < names.length; addIndex++) {
+            this.addSegment(names[addIndex]);
+          }
 
-    for (let addIndex = index; addIndex < names.length; addIndex++) {
-      this.addSegment(names[addIndex]);
+          isDiff = true;
+        }
+      }
     }
 
-    return true;
+    this.setChangeNumber(segmentsData.cn);
+    return isDiff;
   }
 }

package/src/storages/AbstractSplitsCacheSync.ts

@@ -1,4 +1,4 @@
-import { ISplitsCacheSync } from './types';
+import { ISplitsCacheSync, IStorageSync } from './types';
 import { IRBSegment, ISplit } from '../dtos/types';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { IN_SEGMENT, IN_LARGE_SEGMENT } from '../utils/constants';
@@ -14,9 +14,10 @@ export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
   protected abstract setChangeNumber(changeNumber: number): boolean | void
 
   update(toAdd: ISplit[], toRemove: ISplit[], changeNumber: number): boolean {
+    let updated = toAdd.map(addedFF => this.addSplit(addedFF)).some(result => result);
+    updated = toRemove.map(removedFF => this.removeSplit(removedFF.name)).some(result => result) || updated;
     this.setChangeNumber(changeNumber);
-    const updated = toAdd.map(addedFF => this.addSplit(addedFF)).some(result => result);
-    return toRemove.map(removedFF => this.removeSplit(removedFF.name)).some(result => result) || updated;
+    return updated;
   }
 
   abstract getSplit(name: string): ISplit | null
@@ -88,3 +89,7 @@ export function usesSegments(ruleEntity: ISplit | IRBSegment) {
 
   return false;
 }
+
+export function usesSegmentsSync(storage: Pick<IStorageSync, 'splits' | 'rbSegments'>) {
+  return storage.splits.usesSegments() || storage.rbSegments.usesSegments();
+}

package/src/storages/inLocalStorage/MySegmentsCacheInLocal.ts

@@ -3,16 +3,19 @@ import { isNaNNumber } from '../../utils/lang';
 import { AbstractMySegmentsCacheSync } from '../AbstractMySegmentsCacheSync';
 import type { MySegmentsKeyBuilder } from '../KeyBuilderCS';
 import { LOG_PREFIX, DEFINED } from './constants';
+import { StorageAdapter } from '../types';
 
 export class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
 
   private readonly keys: MySegmentsKeyBuilder;
   private readonly log: ILogger;
+  private readonly storage: StorageAdapter;
 
-  constructor(log: ILogger, keys: MySegmentsKeyBuilder) {
+  constructor(log: ILogger, keys: MySegmentsKeyBuilder, storage: StorageAdapter) {
     super();
     this.log = log;
     this.keys = keys;
+    this.storage = storage;
     // There is not need to flush segments cache like splits cache, since resetSegments receives the up-to-date list of active segments
   }
 
@@ -20,8 +23,8 @@ export class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
     const segmentKey = this.keys.buildSegmentNameKey(name);
 
     try {
-      if (localStorage.getItem(segmentKey) === DEFINED) return false;
-      localStorage.setItem(segmentKey, DEFINED);
+      if (this.storage.getItem(segmentKey) === DEFINED) return false;
+      this.storage.setItem(segmentKey, DEFINED);
       return true;
     } catch (e) {
       this.log.error(LOG_PREFIX + e);
@@ -33,8 +36,8 @@ export class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
     const segmentKey = this.keys.buildSegmentNameKey(name);
 
     try {
-      if (localStorage.getItem(segmentKey) !== DEFINED) return false;
-      localStorage.removeItem(segmentKey);
+      if (this.storage.getItem(segmentKey) !== DEFINED) return false;
+      this.storage.removeItem(segmentKey);
       return true;
     } catch (e) {
       this.log.error(LOG_PREFIX + e);
@@ -43,18 +46,16 @@ export class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
   }
 
   isInSegment(name: string): boolean {
-    return localStorage.getItem(this.keys.buildSegmentNameKey(name)) === DEFINED;
+    return this.storage.getItem(this.keys.buildSegmentNameKey(name)) === DEFINED;
   }
 
   getRegisteredSegments(): string[] {
-    // Scan current values from localStorage
-    return Object.keys(localStorage).reduce((accum, key) => {
-      let segmentName = this.keys.extractSegmentName(key);
-
-      if (segmentName) accum.push(segmentName);
-
-      return accum;
-    }, [] as string[]);
+    const registeredSegments: string[] = [];
+    for (let i = 0; i < this.storage.length; i++) {
+      const segmentName = this.keys.extractSegmentName(this.storage.key(i)!);
+      if (segmentName) registeredSegments.push(segmentName);
+    }
+    return registeredSegments;
   }
 
   getKeysCount() {
@@ -63,8 +64,8 @@ export class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
 
   protected setChangeNumber(changeNumber?: number) {
     try {
-      if (changeNumber) localStorage.setItem(this.keys.buildTillKey(), changeNumber + '');
-      else localStorage.removeItem(this.keys.buildTillKey());
+      if (changeNumber) this.storage.setItem(this.keys.buildTillKey(), changeNumber + '');
+      else this.storage.removeItem(this.keys.buildTillKey());
     } catch (e) {
       this.log.error(e);
     }
@@ -72,7 +73,7 @@ export class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
 
   getChangeNumber() {
     const n = -1;
-    let value: string | number | null = localStorage.getItem(this.keys.buildTillKey());
+    let value: string | number | null = this.storage.getItem(this.keys.buildTillKey());
 
     if (value !== null) {
       value = parseInt(value, 10);

package/src/storages/inLocalStorage/RBSegmentsCacheInLocal.ts

@@ -5,34 +5,37 @@ import { isFiniteNumber, isNaNNumber, toNumber } from '../../utils/lang';
 import { setToArray } from '../../utils/lang/sets';
 import { usesSegments } from '../AbstractSplitsCacheSync';
 import { KeyBuilderCS } from '../KeyBuilderCS';
-import { IRBSegmentsCacheSync } from '../types';
+import { IRBSegmentsCacheSync, StorageAdapter } from '../types';
 import { LOG_PREFIX } from './constants';
 
 export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
 
   private readonly keys: KeyBuilderCS;
   private readonly log: ILogger;
+  private readonly storage: StorageAdapter;
 
-  constructor(settings: ISettings, keys: KeyBuilderCS) {
+  constructor(settings: ISettings, keys: KeyBuilderCS, storage: StorageAdapter) {
     this.keys = keys;
     this.log = settings.log;
+    this.storage = storage;
   }
 
   clear() {
     this.getNames().forEach(name => this.remove(name));
-    localStorage.removeItem(this.keys.buildRBSegmentsTillKey());
+    this.storage.removeItem(this.keys.buildRBSegmentsTillKey());
   }
 
   update(toAdd: IRBSegment[], toRemove: IRBSegment[], changeNumber: number): boolean {
+    let updated = toAdd.map(toAdd => this.add(toAdd)).some(result => result);
+    updated = toRemove.map(toRemove => this.remove(toRemove.name)).some(result => result) || updated;
     this.setChangeNumber(changeNumber);
-    const updated = toAdd.map(toAdd => this.add(toAdd)).some(result => result);
-    return toRemove.map(toRemove => this.remove(toRemove.name)).some(result => result) || updated;
+    return updated;
   }
 
   private setChangeNumber(changeNumber: number) {
     try {
-      localStorage.setItem(this.keys.buildRBSegmentsTillKey(), changeNumber + '');
-      localStorage.setItem(this.keys.buildLastUpdatedKey(), Date.now() + '');
+      this.storage.setItem(this.keys.buildRBSegmentsTillKey(), changeNumber + '');
+      this.storage.setItem(this.keys.buildLastUpdatedKey(), Date.now() + '');
     } catch (e) {
       this.log.error(LOG_PREFIX + e);
     }
@@ -40,20 +43,19 @@ export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
 
   private updateSegmentCount(diff: number) {
     const segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
-    const count = toNumber(localStorage.getItem(segmentsCountKey)) + diff;
-    // @ts-expect-error
-    if (count > 0) localStorage.setItem(segmentsCountKey, count);
-    else localStorage.removeItem(segmentsCountKey);
+    const count = toNumber(this.storage.getItem(segmentsCountKey)) + diff;
+    if (count > 0) this.storage.setItem(segmentsCountKey, count + '');
+    else this.storage.removeItem(segmentsCountKey);
   }
 
   private add(rbSegment: IRBSegment): boolean {
     try {
       const name = rbSegment.name;
       const rbSegmentKey = this.keys.buildRBSegmentKey(name);
-      const rbSegmentFromLocalStorage = localStorage.getItem(rbSegmentKey);
-      const previous = rbSegmentFromLocalStorage ? JSON.parse(rbSegmentFromLocalStorage) : null;
+      const rbSegmentFromStorage = this.storage.getItem(rbSegmentKey);
+      const previous = rbSegmentFromStorage ? JSON.parse(rbSegmentFromStorage) : null;
 
-      localStorage.setItem(rbSegmentKey, JSON.stringify(rbSegment));
+      this.storage.setItem(rbSegmentKey, JSON.stringify(rbSegment));
 
       let usesSegmentsDiff = 0;
       if (previous && usesSegments(previous)) usesSegmentsDiff--;
@@ -72,7 +74,7 @@ export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
       const rbSegment = this.get(name);
       if (!rbSegment) return false;
 
-      localStorage.removeItem(this.keys.buildRBSegmentKey(name));
+      this.storage.removeItem(this.keys.buildRBSegmentKey(name));
 
       if (usesSegments(rbSegment)) this.updateSegmentCount(-1);
 
@@ -84,13 +86,13 @@ export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
   }
 
   private getNames(): string[] {
-    const len = localStorage.length;
+    const len = this.storage.length;
     const accum = [];
 
     let cur = 0;
 
     while (cur < len) {
-      const key = localStorage.key(cur);
+      const key = this.storage.key(cur);
 
       if (key != null && this.keys.isRBSegmentKey(key)) accum.push(this.keys.extractKey(key));
 
@@ -101,7 +103,7 @@ export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
   }
 
   get(name: string): IRBSegment | null {
-    const item = localStorage.getItem(this.keys.buildRBSegmentKey(name));
+    const item = this.storage.getItem(this.keys.buildRBSegmentKey(name));
     return item && JSON.parse(item);
   }
 
@@ -113,7 +115,7 @@ export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
 
   getChangeNumber(): number {
     const n = -1;
-    let value: string | number | null = localStorage.getItem(this.keys.buildRBSegmentsTillKey());
+    let value: string | number | null = this.storage.getItem(this.keys.buildRBSegmentsTillKey());
 
     if (value !== null) {
       value = parseInt(value, 10);
@@ -125,7 +127,7 @@ export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
   }
 
   usesSegments(): boolean {
-    const storedCount = localStorage.getItem(this.keys.buildSplitsWithSegmentCountKey());
+    const storedCount = this.storage.getItem(this.keys.buildSplitsWithSegmentCountKey());
     const splitsWithSegmentsCount = storedCount === null ? 0 : toNumber(storedCount);
 
     return isFiniteNumber(splitsWithSegmentsCount) ?