Make it easier to integrate with mobx

Author: dean

.eslintrc.js

@@ -1,10 +1,15 @@
 module.exports = {
+  plugins: ['prettier'],
   extends: [
-    '@nuxtjs/eslint-config-typescript',
+    'plugin:@typescript-eslint/recommended',
     'prettier',
     'prettier/standard',
     'plugin:prettier/recommended',
   ],
-  plugins: ['prettier'],
-  rules: {},
+  rules: {
+    '@typescript-eslint/no-explicit-any': 'off',
+    '@typescript-eslint/ban-types': 'off',
+    '@typescript-eslint/explicit-module-boundary-types': 'off',
+    '@typescript-eslint/ban-ts-comment': 'off',
+  },
 }

__test__/strict-async-storage.spec.ts

@@ -8,6 +8,7 @@ import {
   restoreSaved,
   defLen,
 } from './helper';
+import { autorun, configure, makeObservable, action, observable } from 'mobx';
 
 describe('strict-async-storage', () => {
   jest
@@ -20,29 +21,157 @@ describe('strict-async-storage', () => {
     .mockImplementation((name: string, value: string) => {
       setSaved(name, value);
     });
-  oneSetTest('default sync', new StrictAsyncStorage(defaults));
-
-  oneSetTest(
-    'cunstom async',
-    new StrictAsyncStorage(defaults, {
-      map: new Map(),
-      driver: () => new AsyncDriver(),
-    }),
-    true
-  );
+
+  runTest('sync driver', new StrictAsyncStorage(defaults));
+
+  runTest('async driver', new StrictAsyncStorage(defaults, new AsyncDriver()));
+
+  describe('mobx', () => {
+    configure({
+      enforceActions: 'always',
+      computedRequiresReaction: true,
+      reactionRequiresObservable: true,
+      // observableRequiresReaction: true,
+      // disableErrorBoundaries: true,
+    });
+
+    let strictAsyncStorage: StrictAsyncStorage<
+      {
+        user: string;
+        no: number;
+        enable: boolean;
+        data: {};
+      },
+      StorageName,
+      AsyncDriver
+    >;
+    let view: jest.Mock;
+
+    beforeEach(async () => {
+      restoreSaved();
+
+      strictAsyncStorage = makeObservable(
+        new StrictAsyncStorage(defaults, new AsyncDriver()),
+        {
+          //@ts-expect-error
+          _map: observable,
+          _initialized: observable,
+          _disposed: observable,
+          setMap: action,
+          batchMap: action,
+          setInitialized: action,
+          setDisposed: action,
+        }
+      );
+      await strictAsyncStorage.initialize();
+
+      view = jest.fn(() => {
+        try {
+          return `user:${strictAsyncStorage.getItem(
+            StorageName.user
+          )},no:${strictAsyncStorage.getItem(
+            StorageName.no
+          )},enable:${strictAsyncStorage.getItem(
+            StorageName.enable
+          )},data:${strictAsyncStorage.getItem(StorageName.data)},`;
+        } catch (error) {
+          return error;
+        }
+      });
+
+      autorun(view);
+      view.mockClear();
+    });
+
+    it('test setItem', async () => {
+      const user = 'test001';
+      await strictAsyncStorage.setItem(StorageName.user, user);
+      expect(view).toBeCalledTimes(1);
+      expect(view).lastReturnedWith(
+        `user:${user},no:${123},enable:${defaults[StorageName.enable]},data:${{
+          name: 'John',
+          age: 12,
+        }},`
+      );
+
+      await strictAsyncStorage.setItem(StorageName.user, undefined as any);
+      expect(view).toBeCalledTimes(2);
+      expect(view).lastReturnedWith(
+        `user:${undefined},no:${123},enable:${
+          defaults[StorageName.enable]
+        },data:${{
+          name: 'John',
+          age: 12,
+        }},`
+      );
+
+      await strictAsyncStorage.setItem(StorageName.user, null as any);
+      expect(view).toBeCalledTimes(3);
+      expect(view).lastReturnedWith(
+        `user:${defaults[StorageName.user]},no:${123},enable:${
+          defaults[StorageName.enable]
+        },data:${{
+          name: 'John',
+          age: 12,
+        }},`
+      );
+
+      await expect(
+        strictAsyncStorage.setItem('other' as any, null as any)
+      ).rejects.toThrowError(RangeError);
+      expect(view).toBeCalledTimes(3);
+    });
+
+    it('test resetItem', async () => {
+      await strictAsyncStorage.resetItem(StorageName.no);
+      expect(view).toBeCalledTimes(1);
+      expect(view).lastReturnedWith(
+        `user:${'user001'},no:${defaults[StorageName.no]},enable:${
+          defaults[StorageName.enable]
+        },data:${{
+          name: 'John',
+          age: 12,
+        }},`
+      );
+
+      await expect(
+        strictAsyncStorage.resetItem('other' as any)
+      ).rejects.toThrowError(RangeError);
+      expect(view).toBeCalledTimes(1);
+    });
+
+    it('test resetAll', async () => {
+      await strictAsyncStorage.resetAll();
+      expect(view).toBeCalledTimes(1);
+      expect(view).lastReturnedWith(
+        `user:${defaults[StorageName.user]},no:${
+          defaults[StorageName.no]
+        },enable:${defaults[StorageName.enable]},data:${
+          defaults[StorageName.data]
+        },`
+      );
+    });
+  });
 });
 
-function oneSetTest<TDriver extends DriverInterface = Storage>(
+function runTest<TDriver extends DriverInterface = Storage>(
   testName: string | number | Function | jest.FunctionLike,
-  strictAsyncStorage: StrictAsyncStorage<typeof defaults, StorageName, TDriver>,
-  handleDispose = false
+  strictAsyncStorage: StrictAsyncStorage<typeof defaults, StorageName, TDriver>
 ) {
   describe(testName, () => {
     restoreSaved();
 
-    it('test init', async () => {
-      await strictAsyncStorage.init();
+    it('test initialize', async () => {
+      expect(strictAsyncStorage.initialized).toBeFalsy();
+      await strictAsyncStorage.initialize();
+      expect(strictAsyncStorage.initialized).toBeTruthy();
       expect(strictAsyncStorage.defaults).toEqual(defaults);
+
+      await expect(
+        async () => await strictAsyncStorage.initialize()
+      ).rejects.toThrowError(
+        '[strict-async-storage] Invalid operation. This has been initialized.'
+      );
     });
 
     it('test length', async () => {
@@ -116,20 +245,18 @@ function oneSetTest<TDriver extends DriverInterface = Storage>(
     });
 
     it('test dispose', () => {
-      if (handleDispose) {
-        const handler = jest.fn(() => {
-          expect(() =>
-            strictAsyncStorage.getItem(StorageName.user)
-          ).not.toThrowError();
-        });
-        strictAsyncStorage.dispose(handler);
-        expect(handler).toBeCalled();
-      } else {
-        strictAsyncStorage.dispose();
-      }
-      expect(strictAsyncStorage.length).toBe(0);
+      expect(strictAsyncStorage.disposed).toBeFalsy();
+      strictAsyncStorage.dispose();
+      expect(strictAsyncStorage.disposed).toBeTruthy();
+      expect(() => strictAsyncStorage.dispose()).toThrowError(
+        '[strict-async-storage] Invalid operation. This has been disposed.'
+      );
+
+      expect(() => strictAsyncStorage.length).toThrowError(
+        '[strict-async-storage] Invalid operation. Not initialized yet, failed to initialize or has been disposed.'
+      );
       expect(() => strictAsyncStorage.getItem(StorageName.user)).toThrowError(
-        RangeError
+        '[strict-async-storage] Invalid operation. Not initialized yet, failed to initialize or has been disposed.'
       );
     });
   });