Merge pull request #422 from lightninglabs/save-settings

Save settings

Author: tanx

src/action/app-storage.js

@@ -0,0 +1,47 @@
+import * as log from './log';
+
+class AppStorage {
+  constructor(store, AsyncStorage) {
+    this._store = store;
+    this._AsyncStorage = AsyncStorage;
+  }
+
+  async restore() {
+    try {
+      const stateString = await this._AsyncStorage.getItem('settings');
+      if (!stateString) return;
+      const state = JSON.parse(stateString);
+      Object.keys(state).forEach(key => {
+        if (typeof this._store.settings[key] !== 'undefined') {
+          this._store.settings[key] = state[key];
+        }
+      });
+    } catch (err) {
+      log.error('Store load error', err);
+    } finally {
+      log.info('Loaded initial state');
+      this._store.loaded = true;
+    }
+  }
+
+  async save() {
+    try {
+      const state = JSON.stringify(this._store.settings);
+      await this._AsyncStorage.setItem('settings', state);
+      log.info('Saved state');
+    } catch (error) {
+      log.error('Store save error', error);
+    }
+  }
+
+  async clear() {
+    try {
+      await this._AsyncStorage.clear();
+      log.info('State cleared');
+    } catch (error) {
+      log.error('Store clear error', error);
+    }
+  }
+}
+
+export default AppStorage;

src/action/index.js

@@ -2,6 +2,7 @@ import { observe } from 'mobx';
 import { AsyncStorage, Clipboard } from 'react-native';
 import { nap } from '../helper';
 import store from '../store';
+import AppStorage from './app-storage';
 import GrpcAction from './grpc';
 import NavAction from './nav';
 import WalletAction from './wallet';
@@ -21,13 +22,13 @@ const ipcRenderer = window.ipcRenderer; // exposed to sandbox via preload.js
 //
 
 store.init();
-store.restore(AsyncStorage);
 
+export const db = new AppStorage(store, AsyncStorage);
 export const log = new LogAction(store, ipcRenderer);
 export const nav = new NavAction(store, ipcRenderer);
 export const grpc = new GrpcAction(store, ipcRenderer);
 export const notify = new NotificationAction(store, nav);
-export const wallet = new WalletAction(store, grpc, nav, notify);
+export const wallet = new WalletAction(store, grpc, db, nav, notify);
 export const info = new InfoAction(store, grpc, notify);
 export const channel = new ChannelAction(store, grpc, nav, notify);
 export const transaction = new TransactionAction(store, grpc, wallet, nav);
@@ -40,12 +41,14 @@ export const invoice = new InvoiceAction(
   Clipboard
 );
 export const payment = new PaymentAction(store, grpc, transaction, nav, notify);
-export const setting = new SettingAction(store, wallet);
+export const setting = new SettingAction(store, wallet, db);
 
 //
 // Init actions
 //
 
+db.restore();
+
 observe(store, 'loaded', async () => {
   await grpc.initUnlocker();
 });

src/action/setting.js

@@ -1,16 +1,18 @@
 import { UNITS, FIATS } from '../config';
 
 class SettingAction {
-  constructor(store, wallet) {
+  constructor(store, wallet, db) {
     this._store = store;
     this._wallet = wallet;
+    this._db = db;
   }
 
   setBitcoinUnit({ unit }) {
     if (!UNITS[unit]) {
       throw new Error(`Invalid bitcoin unit: ${unit}`);
     }
     this._store.settings.unit = unit;
+    this._db.save();
   }
 
   setFiatCurrency({ fiat }) {
@@ -19,6 +21,7 @@ class SettingAction {
     }
     this._store.settings.fiat = fiat;
     this._wallet.getExchangeRate();
+    this._db.save();
   }
 }
 

src/action/wallet.js

@@ -3,9 +3,10 @@ import { MIN_PASSWORD_LENGTH, NOTIFICATION_DELAY } from '../config';
 import * as log from './log';
 
 class WalletAction {
-  constructor(store, grpc, nav, notification) {
+  constructor(store, grpc, db, nav, notification) {
     this._store = store;
     this._grpc = grpc;
+    this._db = db;
     this._nav = nav;
     this._notification = notification;
   }
@@ -139,6 +140,7 @@ class WalletAction {
 
   toggleDisplayFiat() {
     this._store.settings.displayFiat = !this._store.settings.displayFiat;
+    this._db.save();
   }
 
   async getBalance() {
@@ -181,6 +183,7 @@ class WalletAction {
       const uri = `https://blockchain.info/tobtc?currency=${fiat}&value=1`;
       const response = checkHttpStatus(await fetch(uri));
       this._store.settings.exchangeRate[fiat] = Number(await response.text());
+      this._db.save();
     } catch (err) {
       log.error('Getting exchange rate failed', err);
     }

src/helper.js

@@ -98,7 +98,7 @@ export const calculateExchangeRate = (satoshis, settings) => {
   ) {
     throw new Error('Invalid input!');
   }
-  const rate = settings.exchangeRate[settings.fiat];
+  const rate = settings.exchangeRate[settings.fiat] || 0;
   const balance = satoshis / rate / UNITS.btc.denominator;
   return formatFiat(balance, settings.fiat);
 };

src/store.js

@@ -1,4 +1,4 @@
-import { extendObservable, action } from 'mobx';
+import { extendObservable } from 'mobx';
 import ComputedWallet from './computed/wallet';
 import ComputedTransaction from './computed/transaction';
 import ComputedChannel from './computed/channel';
@@ -8,7 +8,6 @@ import ComputedNotification from './computed/notification';
 import ComputedSetting from './computed/setting';
 import ComputedSeed from './computed/seed';
 import { DEFAULT_ROUTE, DEFAULT_UNIT, DEFAULT_FIAT } from './config';
-import * as log from './action/log';
 
 export class Store {
   constructor() {
@@ -67,10 +66,7 @@ export class Store {
         unit: DEFAULT_UNIT,
         fiat: DEFAULT_FIAT,
         displayFiat: false,
-        exchangeRate: {
-          usd: null,
-          eur: null,
-        },
+        exchangeRate: {},
       },
     });
   }
@@ -85,44 +81,6 @@ export class Store {
     ComputedSetting(this);
     ComputedSeed(this);
   }
-
-  restore(AsyncStorage) {
-    this._AsyncStorage = AsyncStorage;
-    try {
-      this._AsyncStorage.getItem('settings').then(
-        action(stateString => {
-          const state = JSON.parse(stateString);
-          state &&
-            Object.keys(state).forEach(key => {
-              if (typeof this.settings[key] !== 'undefined') {
-                this.settings[key] = state[key];
-              }
-            });
-          log.info('Loaded initial state');
-          this.loaded = true;
-        })
-      );
-    } catch (err) {
-      log.info('Store load error', err);
-      this.loaded = true;
-    }
-  }
-
-  save() {
-    try {
-      const state = JSON.stringify(this.settings);
-      this._AsyncStorage.setItem('settings', state);
-      log.info('Saved state');
-    } catch (error) {
-      log.info('Store Error', error);
-    }
-  }
-
-  clear() {
-    log.info('!!!!!!!!!CLEARING ALL PERSISTENT DATA!!!!!!');
-    Object.keys(this.settings).map(key => (this.settings[key] = null));
-    this.save();
-  }
 }
 
 export default new Store();

stories/screen.js

@@ -6,6 +6,7 @@ import sinon from 'sinon';
 import { Store } from '../src/store';
 import NavAction from '../src/action/nav';
 import GrpcAction from '../src/action/grpc';
+import AppStorage from '../src/action/app-storage';
 import NotificationAction from '../src/action/notification';
 import SettingAction from '../src/action/setting';
 import WalletAction from '../src/action/wallet';
@@ -46,10 +47,11 @@ import NewAddress from '../src/view/new-address';
 const store = new Store();
 store.init();
 const nav = sinon.createStubInstance(NavAction);
+const db = sinon.createStubInstance(AppStorage);
 const grpc = sinon.createStubInstance(GrpcAction);
 const notify = sinon.createStubInstance(NotificationAction);
-const wallet = new WalletAction(store, grpc, nav, notify);
-const setting = new SettingAction(store, wallet);
+const wallet = new WalletAction(store, grpc, db, nav, notify);
+const setting = new SettingAction(store, wallet, db);
 sinon.stub(wallet, 'update');
 sinon.stub(wallet, 'checkSeed');
 sinon.stub(wallet, 'checkNewPassword');

test/integration/action/action-integration.spec.js

@@ -1,6 +1,7 @@
 import { rmdir, poll, isPortOpen } from './test-util';
 import { Store } from '../../../src/store';
 import GrpcAction from '../../../src/action/grpc';
+import AppStorage from '../../../src/action/app-storage';
 import NavAction from '../../../src/action/nav';
 import * as logger from '../../../src/action/log';
 import NotificationAction from '../../../src/action/notification';
@@ -57,6 +58,8 @@ describe('Action Integration Tests', function() {
 
   let store1;
   let store2;
+  let db1;
+  let db2;
   let sandbox;
   let lndProcess1;
   let lndProcess2;
@@ -133,21 +136,23 @@ describe('Action Integration Tests', function() {
       macaroonsEnabled: MACAROONS_ENABLED,
     });
 
+    db1 = sinon.createStubInstance(AppStorage);
     nav1 = sinon.createStubInstance(NavAction);
     notify1 = sinon.createStubInstance(NotificationAction, nav1);
     grpc1 = new GrpcAction(store1, ipcRendererStub1);
     info1 = new InfoAction(store1, grpc1, notify1);
-    wallet1 = new WalletAction(store1, grpc1, nav1, notify1);
+    wallet1 = new WalletAction(store1, grpc1, db1, nav1, notify1);
     channels1 = new ChannelAction(store1, grpc1, nav1, notify1);
     transactions1 = new TransactionAction(store1, grpc1, wallet1, nav1);
     invoice1 = new InvoiceAction(store1, grpc1, transactions1, nav1, notify1);
     payments1 = new PaymentAction(store1, grpc1, transactions1, nav1, notify1);
 
+    db2 = sinon.createStubInstance(AppStorage);
     nav2 = sinon.createStubInstance(NavAction);
     notify2 = sinon.createStubInstance(NotificationAction, nav2);
     grpc2 = new GrpcAction(store2, ipcRendererStub2);
     info2 = new InfoAction(store2, grpc2, notify2);
-    wallet2 = new WalletAction(store2, grpc2, nav2, notify2);
+    wallet2 = new WalletAction(store2, grpc2, db2, nav2, notify2);
     channels2 = new ChannelAction(store2, grpc2, nav2, notify2);
     transactions2 = new TransactionAction(store2, grpc2, wallet2, nav2);
     invoice2 = new InvoiceAction(store2, grpc2, transactions2, nav2, notify2);

test/unit/action/app-storage.spec.js

@@ -0,0 +1,94 @@
+import { Store } from '../../../src/store';
+import AppStorage from '../../../src/action/app-storage';
+import * as logger from '../../../src/action/log';
+
+describe('Action App Storage Unit Tests', () => {
+  let sandbox;
+  let store;
+  let AsyncStorageStub;
+  let db;
+
+  beforeEach(() => {
+    sandbox = sinon.createSandbox({});
+    sandbox.stub(logger);
+    store = new Store();
+    AsyncStorageStub = {
+      getItem: sinon.stub(),
+      setItem: sinon.stub(),
+      clear: sinon.stub(),
+    };
+    db = new AppStorage(store, AsyncStorageStub);
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+  });
+
+  describe('restore()', () => {
+    it('should use default if nothing is saved yet', async () => {
+      AsyncStorageStub.getItem.resolves(undefined);
+      await db.restore(AsyncStorageStub);
+      expect(store.settings.unit, 'to equal', 'btc');
+      expect(logger.error, 'was not called');
+      expect(store.loaded, 'to be', true);
+    });
+
+    it('should set supported setting', async () => {
+      AsyncStorageStub.getItem
+        .withArgs('settings')
+        .resolves(JSON.stringify({ unit: 'sat' }));
+      await db.restore(AsyncStorageStub);
+      expect(store.settings.unit, 'to equal', 'sat');
+      expect(store.loaded, 'to be', true);
+    });
+
+    it('should set supported object', async () => {
+      AsyncStorageStub.getItem.resolves(
+        JSON.stringify({ exchangeRate: { usd: 0.1 } })
+      );
+      await db.restore(AsyncStorageStub);
+      expect(store.settings.exchangeRate, 'to equal', { usd: 0.1 });
+    });
+
+    it('should not set supported setting', async () => {
+      AsyncStorageStub.getItem.resolves(JSON.stringify({ invalid: 'bar' }));
+      await db.restore(AsyncStorageStub);
+      expect(store.settings.invalid, 'to be', undefined);
+    });
+
+    it('should log error', async () => {
+      AsyncStorageStub.getItem.rejects(new Error('Boom!'));
+      await db.restore(AsyncStorageStub);
+      expect(logger.error, 'was called once');
+      expect(store.loaded, 'to be', true);
+    });
+  });
+
+  describe('save()', () => {
+    it('should save all settings', async () => {
+      store.settings = { foo: 'bar' };
+      await db.save();
+      const state = JSON.stringify(store.settings);
+      expect(AsyncStorageStub.setItem, 'was called with', 'settings', state);
+    });
+
+    it('should log error', async () => {
+      AsyncStorageStub.setItem.rejects(new Error('Boom!'));
+      await db.save();
+      expect(logger.error, 'was called once');
+    });
+  });
+
+  describe('clear()', () => {
+    it('should clear all settings', async () => {
+      await db.clear();
+      expect(AsyncStorageStub.clear, 'was called once');
+    });
+
+    it('should log error', async () => {
+      AsyncStorageStub.clear.rejects(new Error('Boom!'));
+      await db.clear();
+      expect(logger.error, 'was called once');
+    });
+  });
+});