tests: add unit tests

Author: Krzysztof Borowy

babel.config.js

@@ -1,5 +1,15 @@
 module.exports = {
-  presets: ['@babel/preset-typescript'],
+  presets: [
+    '@babel/preset-typescript',
+    [
+      '@babel/preset-env',
+      {
+        targets: {
+          node: 'current',
+        },
+      },
+    ],
+  ],
   plugins: [
     '@babel/proposal-class-properties',
     '@babel/proposal-object-rest-spread',

core/__tests__/AsyncStorage.test.ts

@@ -0,0 +1,121 @@
+import AsyncStorage from '../src/AsyncStorage';
+
+class StorageMock implements IStorageBackend<any> {
+  getSingle = jest.fn();
+  setSingle = jest.fn();
+  getMany = jest.fn();
+  setMany = jest.fn();
+  removeSingle = jest.fn();
+  removeMany = jest.fn();
+  getKeys = jest.fn();
+  dropStorage = jest.fn();
+}
+
+describe('AsyncStorage', () => {
+  const mockedStorage = new StorageMock();
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+  });
+
+  describe('main API', () => {
+    it('handles basic set/read/remove calls', async () => {
+      const as = new AsyncStorage(mockedStorage, {
+        logger: false,
+        errorHandler: false,
+      });
+
+      const key = 'myKey';
+      const value = {
+        name: 'Jerry',
+      };
+
+      // get
+      await as.get(key);
+      expect(mockedStorage.getSingle).toBeCalledWith(key, null);
+
+      //set
+      await as.set(key, value);
+      expect(mockedStorage.setSingle).toBeCalledWith(key, value, null);
+
+      // remove
+      await as.remove(key);
+      expect(mockedStorage.removeSingle).toBeCalledWith(key, null);
+    });
+
+    it('handles basic multi set/read/remove calls', async () => {
+      const keys = ['key1', 'key2', 'key3'];
+      const keyValues = [{key1: 'value1'}, {key2: 'value2'}, {key3: 'value3'}];
+
+      const as = new AsyncStorage(mockedStorage, {
+        logger: false,
+        errorHandler: false,
+      });
+
+      // set
+      await as.setMultiple(keyValues);
+      expect(mockedStorage.setMany).toBeCalledWith(keyValues, null);
+
+      // get
+      await as.getMultiple(keys);
+      expect(mockedStorage.getMany).toBeCalledWith(keys, null);
+
+      // remove
+      await as.removeMultiple(keys);
+      expect(mockedStorage.removeMany).toBeCalledWith(keys, null);
+    });
+
+    it('handles getKeys/clearStorage/instance calls', async () => {
+      const asyncStorage = new AsyncStorage(mockedStorage, {
+        logger: false,
+        errorHandler: false,
+      });
+
+      // instance
+      expect(asyncStorage.instance()).toBe(mockedStorage);
+
+      //drop storage
+      await asyncStorage.clearStorage();
+      expect(mockedStorage.dropStorage).toBeCalledTimes(1);
+
+      // getKeys
+      mockedStorage.getKeys.mockImplementationOnce(() => ['key1', 'key2']);
+      const keys = await asyncStorage.getKeys();
+
+      expect(keys).toEqual(['key1', 'key2']);
+    });
+
+    describe('utils', () => {
+      it('uses logger when provided', async () => {
+        const loggerFunc = jest.fn();
+
+        const as = new AsyncStorage(mockedStorage, {
+          logger: loggerFunc,
+          errorHandler: false,
+        });
+
+        await as.get('key');
+        expect(loggerFunc).toBeCalledTimes(1);
+      });
+
+      it('uses error handler when provided', async () => {
+        const errorHandler = jest.fn();
+
+        const error = new Error('Fatal!');
+        mockedStorage.getSingle.mockImplementationOnce(async () => {
+          throw error;
+        });
+
+        const as = new AsyncStorage(mockedStorage, {
+          errorHandler,
+          logger: false,
+        });
+
+        await as.get('key');
+
+        expect(errorHandler).toBeCalledTimes(1);
+        expect(errorHandler.mock.calls[0][0]).toBe(error);
+      });
+    });
+  });
+});

core/__tests__/core.test.ts

@@ -0,0 +1,84 @@
+import Factory from '../src/';
+import {simpleLogger, simpleErrorHandler} from '../src/defaults';
+
+describe('AsyncStorageFactory', () => {
+  it('Throws when tried to instantiate', () => {
+    expect(() => new Factory()).toThrow();
+  });
+});
+
+describe('SimpleLogger', () => {
+  beforeAll(() => {
+    jest.spyOn(console, 'log').mockImplementation();
+  });
+
+  beforeEach(() => {
+    console.log.mockReset();
+  });
+
+  afterAll(() => {
+    console.log.mockRestore();
+  });
+
+  it('logs basic info about action', () => {
+    const actionInfo: LoggerAction = {
+      action: 'save-single',
+      key: 'MyKey',
+      value: 'MyValue',
+    };
+
+    simpleLogger(actionInfo);
+
+    expect(console.log).toBeCalledTimes(1);
+
+    const callArgs = console.log.mock.calls[0][0];
+    expect(callArgs).toContain('[AsyncStorage]');
+    expect(callArgs).toContain(actionInfo.key);
+    expect(callArgs).toContain(actionInfo.value);
+  });
+
+  it('handles unknown action by logging it', () => {
+    const actionInfo: LoggerAction = {
+      // @ts-ignore need to handle unknown
+      action: 'unknown-action',
+    };
+
+    simpleLogger(actionInfo);
+
+    expect(console.log).toBeCalledTimes(1);
+
+    const callArgs = console.log.mock.calls;
+    expect(callArgs[0][0]).toContain('unknown-action');
+  });
+});
+
+describe('SimpleErrorHandler', () => {
+  beforeAll(() => {
+    jest.spyOn(console, 'error').mockImplementation();
+  });
+
+  beforeEach(() => {
+    console.error.mockReset();
+  });
+
+  afterAll(() => {
+    console.error.mockRestore();
+  });
+  it('logs error when it is a string', () => {
+    const errorMessage = 'Fatal!';
+
+    simpleErrorHandler(errorMessage);
+
+    expect(console.error).toBeCalledTimes(1);
+    expect(console.error.mock.calls[0][0]).toEqual(errorMessage);
+  });
+
+  it('logs error when it is an Error', () => {
+    const error = new Error('Fatal!');
+
+    simpleErrorHandler(error);
+
+    expect(console.error).toBeCalledTimes(1);
+    expect(console.error.mock.calls[0][0]).toEqual(error.message);
+  });
+});

core/src/AsyncStorage.ts

@@ -29,7 +29,7 @@ class AsyncStorage<STR extends IStorageBackend, VAL = StorageModelType<STR>> {
     }
   }
 
-  async get(key: string, opts?: StorageOptions): Promise<VAL | null> {
+  async get(key: string, opts: StorageOptions = null): Promise<VAL | null> {
     let value = null;
     try {
       this.log({
@@ -44,7 +44,11 @@ class AsyncStorage<STR extends IStorageBackend, VAL = StorageModelType<STR>> {
     return value;
   }
 
-  async set(key: string, value: VAL, opts?: StorageOptions): Promise<void> {
+  async set(
+    key: string,
+    value: VAL,
+    opts: StorageOptions = null,
+  ): Promise<void> {
     try {
       this.log({
         action: 'save-single',
@@ -59,7 +63,7 @@ class AsyncStorage<STR extends IStorageBackend, VAL = StorageModelType<STR>> {
 
   async getMultiple(
     keys: Array<string>,
-    opts?: StorageOptions,
+    opts: StorageOptions = null,
   ): Promise<Array<VAL | null>> {
     let values: Array<VAL | null> = [];
 
@@ -78,7 +82,7 @@ class AsyncStorage<STR extends IStorageBackend, VAL = StorageModelType<STR>> {
 
   async setMultiple(
     keyValues: Array<{[key: string]: VAL}>,
-    opts?: StorageOptions,
+    opts: StorageOptions = null,
   ): Promise<void> {
     try {
       this.log({
@@ -91,7 +95,7 @@ class AsyncStorage<STR extends IStorageBackend, VAL = StorageModelType<STR>> {
     }
   }
 
-  async remove(key: string, opts?: StorageOptions): Promise<void> {
+  async remove(key: string, opts: StorageOptions = null): Promise<void> {
     try {
       this.log({
         action: 'delete-single',
@@ -105,7 +109,7 @@ class AsyncStorage<STR extends IStorageBackend, VAL = StorageModelType<STR>> {
 
   async removeMultiple(
     keys: Array<string>,
-    opts?: StorageOptions,
+    opts: StorageOptions = null,
   ): Promise<void> {
     try {
       this.log({
@@ -118,7 +122,7 @@ class AsyncStorage<STR extends IStorageBackend, VAL = StorageModelType<STR>> {
     }
   }
 
-  async getKeys(opts?: StorageOptions): Promise<Array<string>> {
+  async getKeys(opts: StorageOptions = null): Promise<Array<string>> {
     let keys: Array<string> = [];
 
     try {
@@ -133,7 +137,7 @@ class AsyncStorage<STR extends IStorageBackend, VAL = StorageModelType<STR>> {
     return keys;
   }
 
-  async clearStorage(opts?: StorageOptions): Promise<void> {
+  async clearStorage(opts: StorageOptions = null): Promise<void> {
     try {
       this.log({
         action: 'drop',

core/types/index.d.ts

@@ -107,4 +107,4 @@ declare const console: any;
 
 declare type StorageOptions = {
   [key: string]: any;
-};
+} | null;

jest.config.js

@@ -0,0 +1,19 @@
+const commonSettings = {
+  transform: {
+    '^.+\\.tsx?$': 'babel-jest',
+  },
+  globals: {
+    __DEV__: true,
+  },
+};
+
+module.exports = {
+  projects: [
+    {
+      ...commonSettings,
+      displayName: 'core',
+      roots: ['<rootDir>/core', '<rootDir>/storages/**/'],
+      testMatch: ['<rootDir>/core/__tests__/*{.,-}test.ts'],
+    },
+  ],
+};

package.json

@@ -16,36 +16,40 @@
   "author": "Krzysztof Borowy <dev@krizzu.dev>",
   "contributors": [],
   "homepage": "https://github.com/react-native-community/react-native-async-storage#readme",
-
   "repository": {
     "type": "git",
     "url": "https://github.com/react-native-community/react-native-async-storage.git"
   },
   "scripts": {
     "build": "lerna run build",
     "clean": "lerna run clean",
-    "test": "yarn test:lint && yarn test:types",
+    "test": "yarn test:lint && yarn test:unit && yarn test:types",
     "test:lint": "eslint core/src/** storages/**/src",
-    "test:types": "tsc --noEmit --declaration false -emitDeclarationOnly false"
+    "test:types": "tsc --noEmit --declaration false -emitDeclarationOnly false",
+    "test:unit": "jest"
   },
   "devDependencies": {
     "@babel/cli": "7.4.4",
     "@babel/core": "7.4.5",
     "@babel/plugin-proposal-class-properties": "7.4.4",
     "@babel/plugin-proposal-object-rest-spread": "7.4.4",
+    "@babel/preset-env": "7.4.5",
     "@babel/preset-typescript": "7.3.3",
     "@react-native-community/eslint-config": "0.0.5",
+    "@types/jest": "24.0.15",
+    "babel-jest": "24.8.0",
     "eslint": "5.16.0",
+    "jest": "24.8.0",
     "lerna": "3.15.0",
     "typescript": "3.5.2"
   },
-  "license": "MIT",
   "keywords": [
     "react-native",
     "react native",
     "async storage",
     "asyncstorage",
     "async-storage",
     "react native storage"
-  ]
+  ],
+  "license": "MIT"
 }

tsconfig.json

@@ -16,6 +16,7 @@
     "esModuleInterop": true
   },
   "include": [
+    "@types/jest",
     "core/src/",
     "core/types/",
     "core/__tests__/",