Refactor InLocalStorage to use the storage from options

Author: EmilianoSanchez

src/storages/__tests__/RBSegmentsCacheSync.spec.ts

@@ -6,7 +6,8 @@ import { IRBSegmentsCacheSync } from '../types';
 import { fullSettings } from '../../utils/settingsValidation/__tests__/settings.mocks';
 
 const cacheInMemory = new RBSegmentsCacheInMemory();
-const cacheInLocal = new RBSegmentsCacheInLocal(fullSettings, new KeyBuilderCS('SPLITIO', 'user'));
+// eslint-disable-next-line no-undef
+const cacheInLocal = new RBSegmentsCacheInLocal(fullSettings, new KeyBuilderCS('SPLITIO', 'user'), localStorage);
 
 describe.each([cacheInMemory, cacheInLocal])('Rule-based segments cache sync (Memory & LocalStorage)', (cache: IRBSegmentsCacheSync) => {
 

src/storages/inLocalStorage/MySegmentsCacheInLocal.ts

@@ -3,25 +3,28 @@ import { isNaNNumber } from '../../utils/lang';
 import { AbstractMySegmentsCacheSync } from '../AbstractMySegmentsCacheSync';
 import type { MySegmentsKeyBuilder } from '../KeyBuilderCS';
 import { LOG_PREFIX, DEFINED } from './constants';
+import SplitIO from '../../../types/splitio';
 
 export class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
 
   private readonly keys: MySegmentsKeyBuilder;
   private readonly log: ILogger;
+  private readonly localStorage: SplitIO.Storage;
 
-  constructor(log: ILogger, keys: MySegmentsKeyBuilder) {
+  constructor(log: ILogger, keys: MySegmentsKeyBuilder, localStorage: SplitIO.Storage) {
     super();
     this.log = log;
     this.keys = keys;
+    this.localStorage = localStorage;
     // There is not need to flush segments cache like splits cache, since resetSegments receives the up-to-date list of active segments
   }
 
   protected addSegment(name: string): boolean {
     const segmentKey = this.keys.buildSegmentNameKey(name);
 
     try {
-      if (localStorage.getItem(segmentKey) === DEFINED) return false;
-      localStorage.setItem(segmentKey, DEFINED);
+      if (this.localStorage.getItem(segmentKey) === DEFINED) return false;
+      this.localStorage.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.localStorage.getItem(segmentKey) !== DEFINED) return false;
+      this.localStorage.removeItem(segmentKey);
       return true;
     } catch (e) {
       this.log.error(LOG_PREFIX + e);
@@ -43,12 +46,12 @@ export class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
   }
 
   isInSegment(name: string): boolean {
-    return localStorage.getItem(this.keys.buildSegmentNameKey(name)) === DEFINED;
+    return this.localStorage.getItem(this.keys.buildSegmentNameKey(name)) === DEFINED;
   }
 
   getRegisteredSegments(): string[] {
     // Scan current values from localStorage
-    return Object.keys(localStorage).reduce((accum, key) => {
+    return Object.keys(this.localStorage).reduce((accum, key) => {
       let segmentName = this.keys.extractSegmentName(key);
 
       if (segmentName) accum.push(segmentName);
@@ -63,16 +66,16 @@ 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.localStorage.setItem(this.keys.buildTillKey(), changeNumber + '');
+      else this.localStorage.removeItem(this.keys.buildTillKey());
     } catch (e) {
       this.log.error(e);
     }
   }
 
   getChangeNumber() {
     const n = -1;
-    let value: string | number | null = localStorage.getItem(this.keys.buildTillKey());
+    let value: string | number | null = this.localStorage.getItem(this.keys.buildTillKey());
 
     if (value !== null) {
       value = parseInt(value, 10);

src/storages/inLocalStorage/RBSegmentsCacheInLocal.ts

@@ -7,20 +7,23 @@ import { usesSegments } from '../AbstractSplitsCacheSync';
 import { KeyBuilderCS } from '../KeyBuilderCS';
 import { IRBSegmentsCacheSync } from '../types';
 import { LOG_PREFIX } from './constants';
+import SplitIO from '../../../types/splitio';
 
 export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
 
   private readonly keys: KeyBuilderCS;
   private readonly log: ILogger;
+  private readonly localStorage: SplitIO.Storage;
 
-  constructor(settings: ISettings, keys: KeyBuilderCS) {
+  constructor(settings: ISettings, keys: KeyBuilderCS, localStorage: SplitIO.Storage) {
     this.keys = keys;
     this.log = settings.log;
+    this.localStorage = localStorage;
   }
 
   clear() {
     this.getNames().forEach(name => this.remove(name));
-    localStorage.removeItem(this.keys.buildRBSegmentsTillKey());
+    this.localStorage.removeItem(this.keys.buildRBSegmentsTillKey());
   }
 
   update(toAdd: IRBSegment[], toRemove: IRBSegment[], changeNumber: number): boolean {
@@ -31,29 +34,29 @@ export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
 
   private setChangeNumber(changeNumber: number) {
     try {
-      localStorage.setItem(this.keys.buildRBSegmentsTillKey(), changeNumber + '');
-      localStorage.setItem(this.keys.buildLastUpdatedKey(), Date.now() + '');
+      this.localStorage.setItem(this.keys.buildRBSegmentsTillKey(), changeNumber + '');
+      this.localStorage.setItem(this.keys.buildLastUpdatedKey(), Date.now() + '');
     } catch (e) {
       this.log.error(LOG_PREFIX + e);
     }
   }
 
   private updateSegmentCount(diff: number) {
     const segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
-    const count = toNumber(localStorage.getItem(segmentsCountKey)) + diff;
+    const count = toNumber(this.localStorage.getItem(segmentsCountKey)) + diff;
     // @ts-expect-error
-    if (count > 0) localStorage.setItem(segmentsCountKey, count);
-    else localStorage.removeItem(segmentsCountKey);
+    if (count > 0) this.localStorage.setItem(segmentsCountKey, count);
+    else this.localStorage.removeItem(segmentsCountKey);
   }
 
   private add(rbSegment: IRBSegment): boolean {
     try {
       const name = rbSegment.name;
       const rbSegmentKey = this.keys.buildRBSegmentKey(name);
-      const rbSegmentFromLocalStorage = localStorage.getItem(rbSegmentKey);
+      const rbSegmentFromLocalStorage = this.localStorage.getItem(rbSegmentKey);
       const previous = rbSegmentFromLocalStorage ? JSON.parse(rbSegmentFromLocalStorage) : null;
 
-      localStorage.setItem(rbSegmentKey, JSON.stringify(rbSegment));
+      this.localStorage.setItem(rbSegmentKey, JSON.stringify(rbSegment));
 
       let usesSegmentsDiff = 0;
       if (previous && usesSegments(previous)) usesSegmentsDiff--;
@@ -72,7 +75,7 @@ export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
       const rbSegment = this.get(name);
       if (!rbSegment) return false;
 
-      localStorage.removeItem(this.keys.buildRBSegmentKey(name));
+      this.localStorage.removeItem(this.keys.buildRBSegmentKey(name));
 
       if (usesSegments(rbSegment)) this.updateSegmentCount(-1);
 
@@ -84,13 +87,13 @@ export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
   }
 
   private getNames(): string[] {
-    const len = localStorage.length;
+    const len = this.localStorage.length;
     const accum = [];
 
     let cur = 0;
 
     while (cur < len) {
-      const key = localStorage.key(cur);
+      const key = this.localStorage.key(cur);
 
       if (key != null && this.keys.isRBSegmentKey(key)) accum.push(this.keys.extractKey(key));
 
@@ -101,7 +104,7 @@ export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
   }
 
   get(name: string): IRBSegment | null {
-    const item = localStorage.getItem(this.keys.buildRBSegmentKey(name));
+    const item = this.localStorage.getItem(this.keys.buildRBSegmentKey(name));
     return item && JSON.parse(item);
   }
 
@@ -113,7 +116,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.localStorage.getItem(this.keys.buildRBSegmentsTillKey());
 
     if (value !== null) {
       value = parseInt(value, 10);
@@ -125,7 +128,7 @@ export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
   }
 
   usesSegments(): boolean {
-    const storedCount = localStorage.getItem(this.keys.buildSplitsWithSegmentCountKey());
+    const storedCount = this.localStorage.getItem(this.keys.buildSplitsWithSegmentCountKey());
     const splitsWithSegmentsCount = storedCount === null ? 0 : toNumber(storedCount);
 
     return isFiniteNumber(splitsWithSegmentsCount) ?