Added unit tests

Author: zashraf1985

packages/datafile-manager/__mocks__/@react-native-community/async-storage.ts

@@ -0,0 +1,37 @@
+/**
+ * Copyright 2020, Optimizely
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export default class AsyncStorage {
+  static getItem(key: string, callback?: (error?: Error, result?: string) => void): Promise<string | null> {
+    return new Promise((resolve, reject) => {
+      switch (key) {
+        case 'keyThatExists': 
+          resolve('{ "name": "Awesome Object" }')
+          break;
+        case 'keyThatDoesNotExist':
+          resolve(null)
+          break;
+        case 'keyWithInvalidJsonObject':
+          resolve('asdfa }')
+          break;
+      }
+    })
+  }
+
+  static setItem(key: string, value: string, callback?: (error?: Error) => void): Promise<void> {
+    return new Promise(resolve => resolve())
+  }
+}

packages/datafile-manager/__test__/reactNativeAsyncStorageCache.spec.ts

@@ -0,0 +1,79 @@
+/**
+ * Copyright 2020, Optimizely
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import ReactNativeAsyncStorageCache from '../src/reactNativeAsyncStorageCache'
+
+describe('reactNativeAsyncStorageCache', () => {
+  let cacheInstance: ReactNativeAsyncStorageCache
+
+  beforeEach(() => {
+    cacheInstance = new ReactNativeAsyncStorageCache()
+  })
+
+  describe('get', function() { 
+    it('should return correct object when item is found in cache', function(done) {
+      cacheInstance.get('keyThatExists')
+        .then(v => { 
+          expect(v).toEqual({ name: "Awesome Object" })
+          done()
+        })
+    })
+
+    it('should return null if item is not found in cache', function(done) {
+      cacheInstance.get('keyThatDoesNotExist')
+        .then(v => { 
+          expect(v).toBeNull()
+          done()
+        })
+    })
+
+    it('should reject promise error if string has an incorrect JSON format', function(done) {
+      cacheInstance.get('keyWithInvalidJsonObject')
+        .catch(e => {
+          done()
+        })
+    })
+  })
+
+  describe('set', function() { 
+    it('should resolve promise if item was successfully set in the cache', function(done) {
+      const testObj = { name: "Awesome Object" }
+      cacheInstance.set('testKey', testObj).then(() => done())
+    })
+
+    it('should reject promise if item was not set in the cache because of json stringifying error', function(done) {
+      const testObj: any = { name: "Awesome Object" }
+      testObj.myOwnReference = testObj
+      cacheInstance.set('testKey', testObj).catch(() => done())
+    })
+  })
+
+  describe('contains', function() { 
+    it('should return true if object with key exists', function(done) {
+      cacheInstance.contains('keyThatExists').then(v => {
+        expect(v).toBeTruthy()
+        done()
+      })
+    })
+
+    it('should return false if object with key does not exist', function(done) {
+      cacheInstance.contains('keyThatDoesNotExist').then(v => {
+        expect(v).toBeFalsy()
+        done()
+      })
+    })
+  })
+})

packages/datafile-manager/src/reactNativeAsyncStorageCache.ts

@@ -14,43 +14,50 @@
  * limitations under the License.
  */
 
-import { getLogger } from '@optimizely/js-sdk-logging';
-import AsyncStorage from '@react-native-community/async-storage';
+import { getLogger } from '@optimizely/js-sdk-logging'
+import AsyncStorage from '@react-native-community/async-storage'
 
-import PersistentKeyValueCache from './persistentKeyValueCache';
+import PersistentKeyValueCache from './persistentKeyValueCache'
 
 const logger = getLogger('DatafileManager')
 
 export default class ReactNativeAsyncStorageCache implements PersistentKeyValueCache {
 
   get(key: string): Promise<Object | null> {
     return new Promise((resolve, reject) => {
-      AsyncStorage.getItem(key).then((val: String | null) => {
+      AsyncStorage.getItem(key).then((val: string | null) => {
         if (val) {
           try {
-            resolve(JSON.parse(val.valueOf()));
+            resolve(JSON.parse(val))
           } catch (ex) {
-            logger.error('Error Parsing Object from cache');
-            reject(ex);
+            logger.error('Error Parsing Object from cache - %s', ex)
+            reject(ex)
           }
         } else {
-          resolve(null);
+          resolve(null)
         }
-      }).catch(reject);
-    });
+      }).catch(reject)
+    })
   }
 
   set(key: string, val: Object): Promise<void> {
-    return AsyncStorage.setItem(key, typeof val === 'object' ? JSON.stringify(val) : val);
+    return new Promise((resolve, reject) => {
+      try {
+        AsyncStorage.setItem(key, JSON.stringify(val)).then(resolve).catch(reject)
+      } catch (e) {
+        logger.error('Error stringifying Object to Json - %s', e)
+        reject(e)
+      }
+    })
   }
 
   contains(key: string): Promise<Boolean> {
     return new Promise((resolve, reject) =>
-      AsyncStorage.getItem(key).then((val: String | null) => resolve(val !== null)).catch(reject)
+      AsyncStorage.getItem(key).then((val: string | null) => resolve(val !== null)).catch(reject)
     )
   }
 
   remove(key: string): Promise<void> {
-    return AsyncStorage.removeItem(key);
+    return AsyncStorage.removeItem(key)
   }
 }