[FSSDK-10936] test adjustment

Author: junaed-optimizely

__mocks__/@react-native-async-storage/async-storage.ts

@@ -21,55 +21,36 @@ export default class AsyncStorage {
     key: string,
     callback?: (error?: Error, result?: string | null) => void
   ): Promise<string | null> {
-    return new Promise((resolve) => {
-      setTimeout(() => {
-        const value = AsyncStorage.items[key] || null;
-        callback?.(undefined, value);
-        resolve(value);
-      }, 1);
-    });
+    const value = AsyncStorage.items[key] || null;
+    callback?.(undefined, value);
+    return Promise.resolve(value);
   }
-
+  
   static setItem(
     key: string,
     value: string,
     callback?: (error?: Error) => void
   ): Promise<void> {
-    return new Promise((resolve) => {
-      setTimeout(() => {
-        AsyncStorage.items[key] = value;
-        callback?.(undefined);
-        resolve();
-      }, 1);
-    });
+    AsyncStorage.items[key] = value;
+    callback?.(undefined);
+    return Promise.resolve();
   }
-
+  
   static removeItem(
     key: string,
     callback?: (error?: Error, result?: string | null) => void
   ): Promise<string | null> {
-    return new Promise((resolve) => {
-      setTimeout(() => {
-        const value = AsyncStorage.items[key] || null;
-        if (key in AsyncStorage.items) {
-          delete AsyncStorage.items[key];
-        }
-        callback?.(undefined, value);
-        resolve(value);
-      }, 1);
-    });
+    const value = AsyncStorage.items[key] || null;
+    if (key in AsyncStorage.items) {
+      delete AsyncStorage.items[key];
+    }
+    callback?.(undefined, value);
+    return Promise.resolve(value);
   }
-
-  static dumpItems(): Record<string, string> {
-    return { ...AsyncStorage.items }; // Return a copy for immutability
-  }
-
+  
   static clearStore(): Promise<void> {
-    return new Promise((resolve) => {
-      setTimeout(() => {
-        AsyncStorage.items = {};
-        resolve();
-      }, 1);
-    });
+    AsyncStorage.items = {};
+    return Promise.resolve();
   }
+  
 }

lib/utils/cache/async_storage_cache.react_native.spec.ts

@@ -1,4 +1,3 @@
-
 /**
  * Copyright 2022-2024, Optimizely
  *
@@ -15,99 +14,93 @@
  * limitations under the License.
  */
 
-vi.mock('@react-native-async-storage/async-storage', () => {
-  const MockAsyncStorage = {
-    data: new Map<string, any>(),
-    async setItem(key: string, value: string) {
-      this.data.set(key, value);
-    },
-    async getItem(key: string) {
-      return this.data.get(key) || null;
-    },
-    async removeItem(key: string) {
-      this.data.delete(key);
-    },
-    async getAllKeys() {
-      return Array.from(this.data.keys());
-    },
-    async clear() {
-      this.data.clear();
-    },
-    async multiGet(keys: string[]) {
-      return keys.map(key => [key, this.data.get(key)]);
-    },
-  }
-  return { default: MockAsyncStorage };
-});
-
-import { vi, describe, it, expect, beforeEach } from 'vitest';
+import { vi, describe, it, expect } from 'vitest';
 import { AsyncStorageCache } from './async_storage_cache.react_native';
-import AsyncStorage from '@react-native-async-storage/async-storage';
+import AsyncStorage from '../../../__mocks__/@react-native-async-storage/async-storage';
+
+vi.mock('../lib/utils/import.react_native/@react-native-async-storage/async-storage', () => {
+  return {
+    getDefaultAsyncStorage: () => AsyncStorage,
+  };
+});
 
 type TestData = {
   a: number;
   b: string;
   d: { e: boolean };
-}
-
+};
 
 describe('AsyncStorageCache', () => {
-  beforeEach(async () => {
-    await AsyncStorage.clear();
-  });
-
-  it('should store a stringified value in asyncstorage', async () => {
+  it('should store a stringified value in asyncstorag', async () => {
     const cache = new AsyncStorageCache<TestData>();
+
     const data = { a: 1, b: '2', d: { e: true } };
     await cache.set('key', data);
-    expect(await AsyncStorage.getItem('key')).toBe(JSON.stringify(data));
+
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    expect(await cache.asyncStorage.getItem('key')).toBe(JSON.stringify(data));
+    expect(await cache.get('key')).toEqual(data);
   });
 
   it('should return undefined if get is called for a nonexistent key', async () => {
     const cache = new AsyncStorageCache<string>();
+
     expect(await cache.get('nonexistent')).toBeUndefined();
   });
 
   it('should return the value if get is called for an existing key', async () => {
     const cache = new AsyncStorageCache<string>();
     await cache.set('key', 'value');
+
     expect(await cache.get('key')).toBe('value');
   });
 
   it('should return the value after json parsing if get is called for an existing key', async () => {
     const cache = new AsyncStorageCache<TestData>();
     const data = { a: 1, b: '2', d: { e: true } };
     await cache.set('key', data);
+
     expect(await cache.get('key')).toEqual(data);
   });
 
   it('should remove the key from async storage when remove is called', async () => {
     const cache = new AsyncStorageCache<string>();
     await cache.set('key', 'value');
     await cache.remove('key');
-    expect(await AsyncStorage.getItem('key')).toBeNull();
+
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    expect(await cache.asyncStorage.getItem('key')).toBeNull();
   });
 
   it('should remove all keys from async storage when clear is called', async () => {
     const cache = new AsyncStorageCache<string>();
     await cache.set('key1', 'value1');
     await cache.set('key2', 'value2');
-    expect((await AsyncStorage.getAllKeys()).length).toBe(2);
+
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    expect((await cache.asyncStorage.getAllKeys()).length).toBe(2);
     cache.clear();
-    expect((await AsyncStorage.getAllKeys()).length).toBe(0);
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    expect((await cache.asyncStorage.getAllKeys()).length).toBe(0);
   });
 
   it('should return all keys when getKeys is called', async () => {
     const cache = new AsyncStorageCache<string>();
     await cache.set('key1', 'value1');
     await cache.set('key2', 'value2');
+
     expect(await cache.getKeys()).toEqual(['key1', 'key2']);
   });
 
   it('should return an array of values for an array of keys when getBatched is called', async () => {
     const cache = new AsyncStorageCache<string>();
     await cache.set('key1', 'value1');
     await cache.set('key2', 'value2');
+
     expect(await cache.getBatched(['key1', 'key2'])).toEqual(['value1', 'value2']);
   });
 });