Unit tests

Author: EmilianoSanchez

src/storages/KeyBuilder.ts

@@ -41,7 +41,7 @@ export class KeyBuilder {
     return `${this.prefix}.rbsegment.${splitName}`;
   }
 
-  buildRBSegmentTillKey() {
+  buildRBSegmentsTillKey() {
     return `${this.prefix}.rbsegments.till`;
   }
 

src/storages/__tests__/testUtils.ts

@@ -1,4 +1,4 @@
-import { ISplit } from '../../dtos/types';
+import { IRBSegment, ISplit } from '../../dtos/types';
 import { IStorageSync, IStorageAsync, IImpressionsCacheSync, IEventsCacheSync } from '../types';
 
 // Assert that instances created by storage factories have the expected interface
@@ -45,3 +45,9 @@ export const featureFlagTwo: ISplit = { name: 'ff_two', sets: ['t','w','o'] };
 export const featureFlagThree: ISplit = { name: 'ff_three', sets: ['t','h','r','e'] };
 //@ts-ignore
 export const featureFlagWithoutFS: ISplit = { name: 'ff_four' };
+
+// Rule-based segments
+//@ts-ignore
+export const rbSegment: IRBSegment = { name: 'rb_segment', conditions: [{ matcherGroup: { matchers: [{ matcherType: 'EQUAL_TO', unaryNumericMatcherData: { value: 10 } }] } }] };
+//@ts-ignore
+export const rbSegmentWithInSegmentMatcher: IRBSegment = { name: 'rb_segment_with_in_segment_matcher', conditions: [{ matcherGroup: { matchers: [{ matcherType: 'IN_SEGMENT', userDefinedSegmentMatcherData: { segmentName: 'employees' } }] } }] };

src/storages/inLocalStorage/RBSegmentsCacheInLocal.ts

@@ -20,8 +20,9 @@ export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
   }
 
   clear() {
+    this.getNames().forEach(name => this.remove(name));
+    localStorage.removeItem(this.keys.buildRBSegmentsTillKey());
     this.hasSync = false;
-    // SplitsCacheInLocal.clear() does the rest of the job
   }
 
   update(toAdd: IRBSegment[], toRemove: IRBSegment[], changeNumber: number): boolean {
@@ -32,7 +33,7 @@ export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
 
   private setChangeNumber(changeNumber: number) {
     try {
-      localStorage.setItem(this.keys.buildSplitsTillKey(), changeNumber + '');
+      localStorage.setItem(this.keys.buildRBSegmentsTillKey(), changeNumber + '');
       localStorage.setItem(this.keys.buildLastUpdatedKey(), Date.now() + '');
       this.hasSync = true;
     } catch (e) {
@@ -42,7 +43,7 @@ export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
 
   private updateSegmentCount(diff: number){
     const segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
-    const count = toNumber(localStorage.getItem(segmentsCountKey)) - diff;
+    const count = toNumber(localStorage.getItem(segmentsCountKey)) + diff;
     // @ts-expect-error
     if (count > 0) localStorage.setItem(segmentsCountKey, count);
     else localStorage.removeItem(segmentsCountKey);
@@ -79,7 +80,6 @@ export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
       if (usesSegments(rbSegment)) this.updateSegmentCount(-1);
 
       return true;
-
     } catch (e) {
       this.log.error(LOG_PREFIX + e);
       return false;
@@ -116,7 +116,7 @@ export class RBSegmentsCacheInLocal implements IRBSegmentsCacheSync {
 
   getChangeNumber(): number {
     const n = -1;
-    let value: string | number | null = localStorage.getItem(this.keys.buildRBSegmentTillKey());
+    let value: string | number | null = localStorage.getItem(this.keys.buildRBSegmentsTillKey());
 
     if (value !== null) {
       value = parseInt(value, 10);

src/storages/inLocalStorage/SplitsCacheInLocal.ts

@@ -57,16 +57,14 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
 
   private _incrementCounts(split: ISplit) {
     try {
-      if (split) {
-        const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-        // @ts-expect-error
-        localStorage.setItem(ttKey, toNumber(localStorage.getItem(ttKey)) + 1);
+      const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
+      // @ts-expect-error
+      localStorage.setItem(ttKey, toNumber(localStorage.getItem(ttKey)) + 1);
 
-        if (usesSegments(split)) {
-          const segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
-          // @ts-expect-error
-          localStorage.setItem(segmentsCountKey, toNumber(localStorage.getItem(segmentsCountKey)) + 1);
-        }
+      if (usesSegments(split)) {
+        const segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
+        // @ts-expect-error
+        localStorage.setItem(segmentsCountKey, toNumber(localStorage.getItem(segmentsCountKey)) + 1);
       }
     } catch (e) {
       this.log.error(LOG_PREFIX + e);

src/storages/inMemory/__tests__/RBSegmentsCacheSync.spec.ts

@@ -0,0 +1,64 @@
+import { RBSegmentsCacheInMemory } from '../RBSegmentsCacheInMemory';
+import { RBSegmentsCacheInLocal } from '../../inLocalStorage/RBSegmentsCacheInLocal';
+import { KeyBuilderCS } from '../../KeyBuilderCS';
+import { rbSegment, rbSegmentWithInSegmentMatcher } from '../../__tests__/testUtils';
+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'));
+
+describe.each([cacheInMemory, cacheInLocal])('RB SEGMENTS CACHE', (cache: IRBSegmentsCacheSync) => {
+
+  beforeEach(() => {
+    cache.clear();
+  });
+
+  test('clear should reset the cache state', () => {
+    cache.update([rbSegment], [], 1);
+    expect(cache.getChangeNumber()).toBe(1);
+    expect(cache.get(rbSegment.name)).not.toBeNull();
+
+    cache.clear();
+    expect(cache.getChangeNumber()).toBe(-1);
+    expect(cache.get(rbSegment.name)).toBeNull();
+  });
+
+  test('update should add and remove segments correctly', () => {
+    // Add segments
+    const updated1 = cache.update([rbSegment, rbSegmentWithInSegmentMatcher], [], 1);
+    expect(updated1).toBe(true);
+    expect(cache.get(rbSegment.name)).toEqual(rbSegment);
+    expect(cache.get(rbSegmentWithInSegmentMatcher.name)).toEqual(rbSegmentWithInSegmentMatcher);
+    expect(cache.getChangeNumber()).toBe(1);
+
+    // Remove segments
+    const updated2 = cache.update([], [rbSegment], 2);
+    expect(updated2).toBe(true);
+    expect(cache.get(rbSegment.name)).toBeNull();
+    expect(cache.get(rbSegmentWithInSegmentMatcher.name)).toEqual(rbSegmentWithInSegmentMatcher);
+    expect(cache.getChangeNumber()).toBe(2);
+  });
+
+  test('contains should check for segment existence correctly', () => {
+    cache.update([rbSegment, rbSegmentWithInSegmentMatcher], [], 1);
+
+    expect(cache.contains(new Set([rbSegment.name]))).toBe(true);
+    expect(cache.contains(new Set([rbSegment.name, rbSegmentWithInSegmentMatcher.name]))).toBe(true);
+    expect(cache.contains(new Set(['nonexistent']))).toBe(false);
+    expect(cache.contains(new Set([rbSegment.name, 'nonexistent']))).toBe(false);
+  });
+
+  test('usesSegments should track segments usage correctly', () => {
+    expect(cache.usesSegments()).toBe(true); // Initially true when changeNumber is -1
+
+    cache.update([rbSegment], [], 1); // rbSegment doesn't have IN_SEGMENT matcher
+    expect(cache.usesSegments()).toBe(false);
+
+    cache.update([rbSegmentWithInSegmentMatcher], [], 2); // rbSegmentWithInSegmentMatcher has IN_SEGMENT matcher
+    expect(cache.usesSegments()).toBe(true);
+
+    cache.clear();
+    expect(cache.usesSegments()).toBe(true); // True after clear since changeNumber is -1
+  });
+});