Declare setting types

12 files changed, 608 insertions, 315 deletions

diff --git a/test/background/usecases/parsers.test.ts b/test/background/usecases/parsers.test.ts
index 17b034b..f3a64eb 100644
--- a/test/background/usecases/parsers.test.ts
+++ b/test/background/usecases/parsers.test.ts
@@ -3,45 +3,32 @@ import * as parsers from 'background/usecases/parsers';
 describe("shared/commands/parsers", () => {
   describe("#parsers.parseSetOption", () => {
     it('parse set string', () => {
-      let [key, value] = parsers.parseSetOption('encoding=utf-8', { encoding: 'string' });
-      expect(key).to.equal('encoding');
-      expect(value).to.equal('utf-8');
+      let [key, value] = parsers.parseSetOption('hintchars=abcdefgh');
+      expect(key).to.equal('hintchars');
+      expect(value).to.equal('abcdefgh');
     });
 
     it('parse set empty string', () => {
-      let [key, value] = parsers.parseSetOption('encoding=', { encoding: 'string' });
-      expect(key).to.equal('encoding');
+      let [key, value] = parsers.parseSetOption('hintchars=');
+      expect(key).to.equal('hintchars');
       expect(value).to.equal('');
     });
 
-    it('parse set string', () => {
-      let [key, value] = parsers.parseSetOption('history=50', { history: 'number' });
-      expect(key).to.equal('history');
-      expect(value).to.equal(50);
-    });
-
     it('parse set boolean', () => {
-      let [key, value] = parsers.parseSetOption('paste', { paste: 'boolean' });
-      expect(key).to.equal('paste');
+      let [key, value] = parsers.parseSetOption('smoothscroll');
+      expect(key).to.equal('smoothscroll');
       expect(value).to.be.true;
 
-      [key, value] = parsers.parseSetOption('nopaste', { paste: 'boolean' });
-      expect(key).to.equal('paste');
+      [key, value] = parsers.parseSetOption('nosmoothscroll');
+      expect(key).to.equal('smoothscroll');
       expect(value).to.be.false;
     });
 
     it('throws error on unknown property', () => {
-      expect(() => parsers.parseSetOption('charset=utf-8', {})).to.throw(Error, 'Unknown');
-      expect(() => parsers.parseSetOption('smoothscroll', {})).to.throw(Error, 'Unknown');
-      expect(() => parsers.parseSetOption('nosmoothscroll', {})).to.throw(Error, 'Unknown');
-    })
-
-    it('throws error on invalid property', () => {
-      expect(() => parsers.parseSetOption('charset=utf-8', { charset: 'number' })).to.throw(Error, 'Not number');
-      expect(() => parsers.parseSetOption('charset=utf-8', { charset: 'boolean' })).to.throw(Error, 'Invalid');
-      expect(() => parsers.parseSetOption('charset=', { charset: 'boolean' })).to.throw(Error, 'Invalid');
-      expect(() => parsers.parseSetOption('smoothscroll', { smoothscroll: 'string' })).to.throw(Error, 'Invalid');
-      expect(() => parsers.parseSetOption('smoothscroll', { smoothscroll: 'number' })).to.throw(Error, 'Invalid');
-    })
+      expect(() => parsers.parseSetOption('encoding=utf-8')).to.throw(Error, 'Unknown');
+      expect(() => parsers.parseSetOption('paste')).to.throw(Error, 'Unknown');
+      expect(() => parsers.parseSetOption('nopaste')).to.throw(Error, 'Unknown');
+      expect(() => parsers.parseSetOption('smoothscroll=yes')).to.throw(Error, 'Invalid argument');
+    });
   });
 });
diff --git a/test/content/actions/setting.test.ts b/test/content/actions/setting.test.ts
index 0721d5d..c831433 100644
--- a/test/content/actions/setting.test.ts
+++ b/test/content/actions/setting.test.ts
@@ -4,32 +4,40 @@ import * as settingActions from 'content/actions/setting';
 describe("setting actions", () => {
   describe("set", () => {
     it('create SETTING_SET action', () => {
-      let action = settingActions.set({ red: 'apple', yellow: 'banana' });
+      let action = settingActions.set({
+        keymaps: {
+          'dd': 'remove current tab',
+          'z<C-A>': 'increment',
+        },
+        search: {
+          default: "google",
+          engines: {
+            google: 'https://google.com/search?q={}',
+          }
+        },
+        properties: {
+          hintchars: 'abcd1234',
+        },
+        blacklist: [],
+      });
       expect(action.type).to.equal(actions.SETTING_SET);
-      expect(action.value.red).to.equal('apple');
-      expect(action.value.yellow).to.equal('banana');
-      expect(action.value.keymaps).to.be.empty;
+      expect(action.settings.properties.hintchars).to.equal('abcd1234');
     });
 
-    it('converts keymaps', () => {
+    it('overrides cancel keys', () => {
       let action = settingActions.set({
         keymaps: {
-          'dd': 'remove current tab',
-          'z<C-A>': 'increment',
+          "k": { "type": "scroll.vertically", "count": -1 },
+          "j": { "type": "scroll.vertically", "count": 1 },
         }
       });
-      let keymaps = action.value.keymaps;
-      let map = new Map(keymaps);
-      expect(map).to.have.deep.all.keys(
-        [
-          [{ key: 'Esc', shiftKey: false, ctrlKey: false, altKey: false, metaKey: false }],
-          [{ key: '[', shiftKey: false, ctrlKey: true, altKey: false, metaKey: false }],
-          [{ key: 'd', shiftKey: false, ctrlKey: false, altKey: false, metaKey: false },
-           { key: 'd', shiftKey: false, ctrlKey: false, altKey: false, metaKey: false }],
-          [{ key: 'z', shiftKey: false, ctrlKey: false, altKey: false, metaKey: false },
-           { key: 'a', shiftKey: false, ctrlKey: true, altKey: false, metaKey: false }],
-        ]
-      );
+      let keymaps = action.settings.keymaps;
+      expect(action.settings.keymaps).to.deep.equals({
+        "k": { type: "scroll.vertically", count: -1 },
+        "j": { type: "scroll.vertically", count: 1 },
+        '<Esc>': { type: 'cancel' },
+        '<C-[>': { type: 'cancel' },
+      });
     });
   });
 });
diff --git a/test/content/reducers/setting.test.ts b/test/content/reducers/setting.test.ts
index 226fc58..fe23006 100644
--- a/test/content/reducers/setting.test.ts
+++ b/test/content/reducers/setting.test.ts
@@ -9,9 +9,24 @@ describe("content setting reducer", () => {
 
   it('return next state for SETTING_SET', () => {
     let newSettings = { red: 'apple', yellow: 'banana' };
-    let action = { type: actions.SETTING_SET, value: newSettings };
+    let action = {
+      type: actions.SETTING_SET,
+      settings: {
+        keymaps: {
+          "zz": { type: "zoom.neutral" },
+          "<S-Esc>": { "type": "addon.toggle.enabled" }
+        },
+        "blacklist": []
+      }
+    }
     let state = settingReducer(undefined, action);
-    expect(state).to.deep.equal(newSettings);
-    expect(state).not.to.equal(newSettings);  // assert deep copy
+    console.log(JSON.stringify(state.keymaps));
+    expect(state.keymaps).to.have.deep.all.members([
+      { key: [{ key: 'z', shiftKey: false, ctrlKey: false, altKey: false, metaKey: false },
+              { key: 'z', shiftKey: false, ctrlKey: false, altKey: false, metaKey: false }],
+        op: { type: 'zoom.neutral' }},
+      { key: [{ key: 'Esc', shiftKey: true, ctrlKey: false, altKey: false, metaKey: false }],
+        op: { type: 'addon.toggle.enabled' }},
+    ]);
   });
 });
diff --git a/test/settings/components/form/KeymapsForm.test.tsx b/test/settings/components/form/KeymapsForm.test.tsx
index 6ac57c9..dc2322b 100644
--- a/test/settings/components/form/KeymapsForm.test.tsx
+++ b/test/settings/components/form/KeymapsForm.test.tsx
@@ -2,15 +2,17 @@ import React from 'react';
 import ReactDOM from 'react-dom';
 import ReactTestRenderer from 'react-test-renderer';
 import ReactTestUtils from 'react-dom/test-utils';
-import KeymapsForm from 'settings/components/form/KeymapsForm'
+import KeymapsForm from '../../../../src/settings/components/form/KeymapsForm'
+import { FormKeymaps } from 'shared/SettingData';
+import { expect } from 'chai';
 
 describe("settings/form/KeymapsForm", () => {
   describe('render', () => {
     it('renders keymap fields', () => {
-      let root = ReactTestRenderer.create(<KeymapsForm value={{
+      let root = ReactTestRenderer.create(<KeymapsForm value={FormKeymaps.valueOf({
         'scroll.vertically?{"count":1}': 'j',
         'scroll.vertically?{"count":-1}': 'k',
-      }} />).root
+      })} />).root
 
       let inputj = root.findByProps({ id: 'scroll.vertically?{"count":1}' });
       let inputk = root.findByProps({ id: 'scroll.vertically?{"count":-1}' });
@@ -46,12 +48,12 @@ describe("settings/form/KeymapsForm", () => {
     it('invokes onChange event on edit', (done) => {
       ReactTestUtils.act(() => {
         ReactDOM.render(<KeymapsForm
-          value={{
+          value={FormKeymaps.valueOf({
             'scroll.vertically?{"count":1}': 'j',
             'scroll.vertically?{"count":-1}': 'k',
-          }}
+          })}
           onChange={value => {
-            expect(value['scroll.vertically?{"count":1}']).to.equal('jjj');
+            expect(value.toJSON()['scroll.vertically?{"count":1}']).to.equal('jjj');
             done();
           }} />, container);
       });
diff --git a/test/settings/components/form/SearchEngineForm.test.tsx b/test/settings/components/form/SearchEngineForm.test.tsx
index 06822f2..0e6b17d 100644
--- a/test/settings/components/form/SearchEngineForm.test.tsx
+++ b/test/settings/components/form/SearchEngineForm.test.tsx
@@ -3,14 +3,15 @@ import ReactDOM from 'react-dom';
 import ReactTestRenderer from 'react-test-renderer';
 import ReactTestUtils from 'react-dom/test-utils';
 import SearchForm from 'settings/components/form/SearchForm'
+import { FormSearch } from 'shared/SettingData';
 
 describe("settings/form/SearchForm", () => {
   describe('render', () => {
     it('renders SearchForm', () => {
-      let root = ReactTestRenderer.create(<SearchForm value={{
+      let root = ReactTestRenderer.create(<SearchForm value={FormSearch.valueOf({
         default: 'google',
         engines: [['google', 'google.com'], ['yahoo', 'yahoo.com']],
-      }} />).root;
+      })} />).root;
 
       let names = root.findAllByProps({ name: 'name' });
       expect(names).to.have.lengthOf(2);
@@ -22,28 +23,6 @@ describe("settings/form/SearchForm", () => {
       expect(urls[0].props.value).to.equal('google.com');
       expect(urls[1].props.value).to.equal('yahoo.com');
     });
-
-    it('renders blank value', () => {
-      let root = ReactTestRenderer.create(<SearchForm />).root;
-
-      let names = root.findAllByProps({ name: 'name' });
-      expect(names).to.be.empty;
-
-      let urls = root.findAllByProps({ name: 'url' });
-      expect(urls).to.be.empty;
-    });
-
-    it('renders blank engines', () => {
-      let root = ReactTestRenderer.create(
-        <SearchForm value={{ default: 'google' }} />,
-      ).root;
-
-      let names = root.findAllByProps({ name: 'name' });
-      expect(names).to.be.empty;
-
-      let urls = root.findAllByProps({ name: 'url' });
-      expect(urls).to.be.empty;
-    });
   });
 
   describe('onChange event', () => {
@@ -62,14 +41,15 @@ describe("settings/form/SearchForm", () => {
     it('invokes onChange event on edit', (done) => {
       ReactTestUtils.act(() => {
         ReactDOM.render(<SearchForm
-          value={{
+          value={FormSearch.valueOf({
             default: 'google',
               engines: [['google', 'google.com'], ['yahoo', 'yahoo.com']]
-          }}
+          })}
           onChange={value => {
-            expect(value.default).to.equal('louvre');
-            expect(value.engines).to.have.lengthOf(2)
-            expect(value.engines).to.have.deep.members(
+            let json = value.toJSON();
+            expect(json.default).to.equal('louvre');
+            expect(json.engines).to.have.lengthOf(2)
+            expect(json.engines).to.have.deep.members(
               [['louvre', 'google.com'], ['yahoo', 'yahoo.com']]
             );
             done();
@@ -87,14 +67,15 @@ describe("settings/form/SearchForm", () => {
 
     it('invokes onChange event on delete', (done) => {
       ReactTestUtils.act(() => {
-        ReactDOM.render(<SearchForm value={{
+        ReactDOM.render(<SearchForm value={FormSearch.valueOf({
             default: 'yahoo',
             engines: [['louvre', 'google.com'], ['yahoo', 'yahoo.com']]
-          }}
+          })}
           onChange={value => {
-            expect(value.default).to.equal('yahoo');
-            expect(value.engines).to.have.lengthOf(1)
-            expect(value.engines).to.have.deep.members(
+            let json = value.toJSON();
+            expect(json.default).to.equal('yahoo');
+            expect(json.engines).to.have.lengthOf(1)
+            expect(json.engines).to.have.deep.members(
               [['yahoo', 'yahoo.com']]
             );
             done();
@@ -107,14 +88,15 @@ describe("settings/form/SearchForm", () => {
 
     it('invokes onChange event on add', (done) => {
       ReactTestUtils.act(() => {
-        ReactDOM.render(<SearchForm value={{
+        ReactDOM.render(<SearchForm value={FormSearch.valueOf({
           default: 'yahoo',
             engines: [['google', 'google.com']]
-          }}
+          })}
           onChange={value => {
-            expect(value.default).to.equal('yahoo');
-            expect(value.engines).to.have.lengthOf(2)
-            expect(value.engines).to.have.deep.members(
+            let json = value.toJSON();
+            expect(json.default).to.equal('yahoo');
+            expect(json.engines).to.have.lengthOf(2)
+            expect(json.engines).to.have.deep.members(
               [['google', 'google.com'], ['', '']],
             );
             done();
diff --git a/test/settings/reducers/setting.test.ts b/test/settings/reducers/setting.test.ts
index 6a874e8..376d66e 100644
--- a/test/settings/reducers/setting.test.ts
+++ b/test/settings/reducers/setting.test.ts
@@ -4,8 +4,7 @@ import settingReducer from 'settings/reducers/setting';
 describe("settings setting reducer", () => {
   it('return the initial state', () => {
     let state = settingReducer(undefined, {});
-    expect(state).to.have.deep.property('json', '');
-    expect(state).to.have.deep.property('form', null);
+    expect(state).to.have.deep.property('source', 'json');
     expect(state).to.have.deep.property('error', '');
   });
 
diff --git a/test/shared/SettingData.test.ts b/test/shared/SettingData.test.ts
new file mode 100644
index 0000000..8736ecb
--- /dev/null
+++ b/test/shared/SettingData.test.ts
@@ -0,0 +1,293 @@
+import SettingData, {
+  FormKeymaps, JSONSettings, FormSettings,
+} from '../../src/shared/SettingData';
+import Settings, { Keymaps } from '../../src/shared/Settings';
+import { expect } from 'chai';
+
+describe('shared/SettingData', () => {
+  describe('FormKeymaps', () => {
+    describe('#valueOF to #toKeymaps', () => {
+      it('parses form keymaps and convert to operations', () => {
+        let data = {
+          'scroll.vertically?{"count":1}': 'j',
+          'scroll.home': '0',
+        }
+
+        let keymaps = FormKeymaps.valueOf(data).toKeymaps();
+        expect(keymaps).to.deep.equal({
+          'j': { type: 'scroll.vertically', count: 1 },
+          '0': { type: 'scroll.home' },
+        });
+      });
+    });
+
+    describe('#fromKeymaps to #toJSON', () => {
+      it('create from a Keymaps and create a JSON object', () => {
+        let data: Keymaps = {
+          'j': { type: 'scroll.vertically', count: 1 },
+          '0': { type: 'scroll.home' },
+        }
+
+        let keymaps = FormKeymaps.fromKeymaps(data).toJSON();
+        expect(keymaps).to.deep.equal({
+          'scroll.vertically?{"count":1}': 'j',
+          'scroll.home': '0',
+        });
+      });
+    });
+  });
+
+  describe('JSONSettings', () => {
+    describe('#valueOf to #toSettings', () => {
+      it('parse object and create a Settings', () => {
+        let o = `{
+          "keymaps": {},
+          "search": {
+            "default": "google",
+            "engines": {
+              "google": "https://google.com/search?q={}"
+            }
+          },
+          "properties": {
+            "hintchars": "abcdefghijklmnopqrstuvwxyz",
+            "smoothscroll": false,
+            "complete": "sbh"
+          },
+          "blacklist": []
+        }`;
+
+        let settings = JSONSettings.valueOf(o).toSettings();
+        expect(settings).to.deep.equal(JSON.parse(o));
+      });
+    });
+
+    describe('#fromSettings to #toJSON', () => {
+      it('create from a Settings and create a JSON string', () => {
+        let o = {
+          keymaps: {},
+          search: {
+            default: "google",
+            engines: {
+              google: "https://google.com/search?q={}",
+            },
+          },
+          properties: {
+            hintchars: "abcdefghijklmnopqrstuvwxyz",
+            smoothscroll: false,
+            complete: "sbh"
+          },
+          blacklist: [],
+        };
+
+        let json = JSONSettings.fromSettings(o).toJSON();
+        expect(JSON.parse(json)).to.deep.equal(o);
+      });
+    });
+  });
+
+  describe('FormSettings', () => {
+    describe('#valueOf to #toSettings', () => {
+      it('parse object and create a Settings', () => {
+        let data = {
+          keymaps: {
+            'scroll.vertically?{"count":1}': 'j',
+            'scroll.home': '0',
+          },
+          search: {
+            default: "google",
+            engines: [
+              ["google", "https://google.com/search?q={}"],
+            ]
+          },
+          properties: {
+            hintchars: "abcdefghijklmnopqrstuvwxyz",
+            smoothscroll: false,
+            complete: "sbh"
+          },
+          blacklist: []
+        };
+
+        let settings = FormSettings.valueOf(data).toSettings();
+        expect(settings).to.deep.equal({
+          keymaps: {
+            'j': { type: 'scroll.vertically', count: 1 },
+            '0': { type: 'scroll.home' },
+          },
+          search: {
+            default: "google",
+            engines: {
+              "google": "https://google.com/search?q={}"
+            }
+          },
+          properties: {
+            hintchars: "abcdefghijklmnopqrstuvwxyz",
+            smoothscroll: false,
+            complete: "sbh"
+          },
+          blacklist: []
+        });
+      });
+    });
+
+    describe('#fromSettings to #toJSON', () => {
+      it('create from a Settings and create a JSON string', () => {
+        let data: Settings = {
+          keymaps: {
+            'j': { type: 'scroll.vertically', count: 1 },
+            '0': { type: 'scroll.home' },
+          },
+          search: {
+            default: "google",
+            engines: {
+              "google": "https://google.com/search?q={}"
+            }
+          },
+          properties: {
+            hintchars: "abcdefghijklmnopqrstuvwxyz",
+            smoothscroll: false,
+            complete: "sbh"
+          },
+          blacklist: []
+        };
+
+        let json = FormSettings.fromSettings(data).toJSON();
+        expect(json).to.deep.equal({
+          keymaps: {
+            'scroll.vertically?{"count":1}': 'j',
+            'scroll.home': '0',
+          },
+          search: {
+            default: "google",
+            engines: [
+              ["google", "https://google.com/search?q={}"],
+            ]
+          },
+          properties: {
+            hintchars: "abcdefghijklmnopqrstuvwxyz",
+            smoothscroll: false,
+            complete: "sbh"
+          },
+          blacklist: [],
+        });
+      });
+    });
+  });
+
+  describe('SettingData', () => {
+    describe('#valueOf to #toJSON', () => {
+      it('parse object from json source', () => {
+        let data = {
+          source: 'json',
+          json: `{
+            "keymaps": {},
+            "search": {
+              "default": "google",
+              "engines": {
+                "google": "https://google.com/search?q={}"
+              }
+            },
+            "properties": {
+              "hintchars": "abcdefghijklmnopqrstuvwxyz",
+              "smoothscroll": false,
+              "complete": "sbh"
+            },
+            "blacklist": []
+          }`,
+        };
+
+        let j = SettingData.valueOf(data).toJSON();
+        expect(j.source).to.equal('json');
+        expect(j.json).to.be.a('string');
+      });
+
+      it('parse object from form source', () => {
+        let data = {
+          source: 'form',
+          form: {
+            keymaps: {},
+            search: {
+              default: "yahoo",
+              engines: [
+                ['yahoo', 'https://yahoo.com/search?q={}'],
+              ],
+            },
+            properties: {
+              hintchars: "abcdefghijklmnopqrstuvwxyz",
+              smoothscroll: false,
+              complete: "sbh"
+            },
+            blacklist: [],
+          },
+        };
+
+        let j = SettingData.valueOf(data).toJSON();
+        expect(j.source).to.equal('form');
+        expect(j.form).to.deep.equal({
+          keymaps: {},
+          search: {
+            default: "yahoo",
+            engines: [
+              ['yahoo', 'https://yahoo.com/search?q={}'],
+            ],
+          },
+          properties: {
+            hintchars: "abcdefghijklmnopqrstuvwxyz",
+            smoothscroll: false,
+            complete: "sbh"
+          },
+          blacklist: [],
+        });
+      });
+    });
+
+    describe('#toSettings', () => {
+      it('parse object from json source', () => {
+        let data = {
+          source: 'json',
+          json: `{
+            "keymaps": {},
+            "search": {
+              "default": "google",
+              "engines": {
+                "google": "https://google.com/search?q={}"
+              }
+            },
+            "properties": {
+              "hintchars": "abcdefghijklmnopqrstuvwxyz",
+              "smoothscroll": false,
+              "complete": "sbh"
+            },
+            "blacklist": []
+          }`,
+        };
+
+        let settings = SettingData.valueOf(data).toSettings();
+        expect(settings.search.default).to.equal('google');
+      });
+
+      it('parse object from form source', () => {
+        let data = {
+          source: 'form',
+          form: {
+            keymaps: {},
+            search: {
+              default: "yahoo",
+              engines: [
+                ['yahoo', 'https://yahoo.com/search?q={}'],
+              ],
+            },
+            properties: {
+              hintchars: "abcdefghijklmnopqrstuvwxyz",
+              smoothscroll: false,
+              complete: "sbh"
+            },
+            blacklist: [],
+          },
+        };
+
+        let settings = SettingData.valueOf(data).toSettings();
+        expect(settings.search.default).to.equal('yahoo');
+      });
+    });
+  });
+});
diff --git a/test/shared/Settings.test.ts b/test/shared/Settings.test.ts
new file mode 100644
index 0000000..02cd022
--- /dev/null
+++ b/test/shared/Settings.test.ts
@@ -0,0 +1,190 @@
+import * as settings from '../../src/shared/Settings';
+import { expect } from 'chai';
+
+describe('Settings', () => {
+  describe('#keymapsValueOf', () => {
+    it('returns empty object by empty settings', () => {
+      let keymaps = settings.keymapsValueOf({});
+      expect(keymaps).to.be.empty;
+    });
+
+    it('returns keymaps by valid settings', () => {
+      let keymaps = settings.keymapsValueOf({
+        k: { type: "scroll.vertically", count: -1 },
+        j: { type: "scroll.vertically", count: 1 },
+      });
+
+      expect(keymaps['k']).to.deep.equal({ type: "scroll.vertically", count: -1 });
+      expect(keymaps['j']).to.deep.equal({ type: "scroll.vertically", count: 1 });
+    });
+
+    it('throws a TypeError by invalid settings', () => {
+      expect(() => settings.keymapsValueOf(null)).to.throw(TypeError);
+      expect(() => settings.keymapsValueOf({
+        k: { type: "invalid.operation" },
+      })).to.throw(TypeError);
+    });
+  });
+
+  describe('#searchValueOf', () => {
+    it('returns search settings by valid settings', () => {
+      let search = settings.searchValueOf({
+        default: "google",
+        engines: {
+          "google": "https://google.com/search?q={}",
+          "yahoo": "https://search.yahoo.com/search?p={}",
+        }
+      });
+
+      expect(search).to.deep.equal({
+        default: "google",
+        engines: {
+          "google": "https://google.com/search?q={}",
+          "yahoo": "https://search.yahoo.com/search?p={}",
+        }
+      });
+    });
+
+    it('throws a TypeError by invalid settings', () => {
+      expect(() => settings.searchValueOf(null)).to.throw(TypeError);
+      expect(() => settings.searchValueOf({})).to.throw(TypeError);
+      expect(() => settings.searchValueOf([])).to.throw(TypeError);
+      expect(() => settings.searchValueOf({
+        default: 123,
+        engines: {}
+      })).to.throw(TypeError);
+      expect(() => settings.searchValueOf({
+        default: "google",
+        engines: {
+          "google": 123456,
+        }
+      })).to.throw(TypeError);
+      expect(() => settings.searchValueOf({
+        default: "wikipedia",
+        engines: {
+          "google": "https://google.com/search?q={}",
+          "yahoo": "https://search.yahoo.com/search?p={}",
+        }
+      })).to.throw(TypeError);
+      expect(() => settings.searchValueOf({
+        default: "g o o g l e",
+        engines: {
+          "g o o g l e": "https://google.com/search?q={}",
+        }
+      })).to.throw(TypeError);
+      expect(() => settings.searchValueOf({
+        default: "google",
+        engines: {
+          "google": "https://google.com/search",
+        }
+      })).to.throw(TypeError);
+      expect(() => settings.searchValueOf({
+        default: "google",
+        engines: {
+          "google": "https://google.com/search?q={}&r={}",
+        }
+      })).to.throw(TypeError);
+    });
+  });
+
+  describe('#propertiesValueOf', () => {
+    it('returns with default properties by empty settings', () => {
+      let props = settings.propertiesValueOf({});
+      expect(props).to.deep.equal({
+        hintchars: "abcdefghijklmnopqrstuvwxyz",
+        smoothscroll: false,
+        complete: "sbh"
+      })
+    });
+
+    it('returns properties by valid settings', () => {
+      let props = settings.propertiesValueOf({
+        hintchars: "abcdefgh",
+        smoothscroll: false,
+        complete: "sbh"
+      });
+
+      expect(props).to.deep.equal({
+        hintchars: "abcdefgh",
+        smoothscroll: false,
+        complete: "sbh"
+      });
+    });
+
+    it('throws a TypeError by invalid settings', () => {
+      expect(() => settings.keymapsValueOf(null)).to.throw(TypeError);
+      expect(() => settings.keymapsValueOf({
+        smoothscroll: 'false',
+      })).to.throw(TypeError);
+      expect(() => settings.keymapsValueOf({
+        unknown: 'xyz'
+      })).to.throw(TypeError);
+    });
+  });
+
+  describe('#blacklistValueOf', () => {
+    it('returns empty array by empty settings', () => {
+      let blacklist = settings.blacklistValueOf([]);
+      expect(blacklist).to.be.empty;
+    });
+
+    it('returns blacklist by valid settings', () => {
+      let blacklist = settings.blacklistValueOf([
+        "github.com",
+        "circleci.com",
+      ]);
+
+      expect(blacklist).to.deep.equal([
+        "github.com",
+        "circleci.com",
+      ]);
+    });
+
+    it('throws a TypeError by invalid settings', () => {
+      expect(() => settings.blacklistValueOf(null)).to.throw(TypeError);
+      expect(() => settings.blacklistValueOf({})).to.throw(TypeError);
+      expect(() => settings.blacklistValueOf([1,2,3])).to.throw(TypeError);
+    });
+  });
+
+  describe('#valueOf', () => {
+    it('returns settings by valid settings', () => {
+      let x = settings.valueOf({
+        keymaps: {},
+        "search": {
+          "default": "google",
+          "engines": {
+            "google": "https://google.com/search?q={}",
+          }
+        },
+        "properties": {},
+        "blacklist": []
+      });
+
+      expect(x).to.deep.equal({
+        keymaps: {},
+        search: {
+          default: "google",
+          engines: {
+            google: "https://google.com/search?q={}",
+          }
+        },
+        properties: {
+          hintchars: "abcdefghijklmnopqrstuvwxyz",
+          smoothscroll: false,
+          complete: "sbh"
+        },
+        blacklist: []
+      });
+    });
+
+    it('sets default settings', () => {
+      let value = settings.valueOf({});
+      expect(value.keymaps).to.not.be.empty;
+      expect(value.properties).to.not.be.empty;
+      expect(value.search.default).to.be.a('string');
+      expect(value.search.engines).to.be.an('object');
+      expect(value.blacklist).to.be.empty;
+    });
+  });
+});
diff --git a/test/shared/properties.test.js b/test/shared/properties.test.js
new file mode 100644
index 0000000..37903d8
--- /dev/null
+++ b/test/shared/properties.test.js
@@ -0,0 +1,18 @@
+import * as settings from 'shared/settings';
+
+describe('properties', () => {
+  describe('Def class', () => {
+    it('returns property definitions', () => {
+      let def = new proerties.Def(
+        'smoothscroll',
+        'smooth scroll',
+        false);
+
+      expect(def.name).to.equal('smoothscroll');
+      expect(def.describe).to.equal('smooth scroll');
+      expect(def.defaultValue).to.equal(false);
+      expect(def.type).to.equal('boolean');
+    });
+  });
+});
+
diff --git a/test/shared/property-defs.test.js b/test/shared/property-defs.test.js
new file mode 100644
index 0000000..37903d8
--- /dev/null
+++ b/test/shared/property-defs.test.js
@@ -0,0 +1,18 @@
+import * as settings from 'shared/settings';
+
+describe('properties', () => {
+  describe('Def class', () => {
+    it('returns property definitions', () => {
+      let def = new proerties.Def(
+        'smoothscroll',
+        'smooth scroll',
+        false);
+
+      expect(def.name).to.equal('smoothscroll');
+      expect(def.describe).to.equal('smooth scroll');
+      expect(def.defaultValue).to.equal(false);
+      expect(def.type).to.equal('boolean');
+    });
+  });
+});
+
diff --git a/test/shared/settings/validator.test.ts b/test/shared/settings/validator.test.ts
deleted file mode 100644
index 9bbfa3e..0000000
--- a/test/shared/settings/validator.test.ts
+++ /dev/null
@@ -1,81 +0,0 @@
-import { validate } from 'shared/settings/validator';
-
-describe("setting validator", () => {
-  describe("unknown top keys", () => {
-    it('throws an error for unknown settings', () => {
-      let settings = { keymaps: {}, poison: 123 };
-      let fn = validate.bind(undefined, settings)
-      expect(fn).to.throw(Error, 'poison');
-    })
-  });
-
-  describe("keymaps settings", () => {
-    it('throws an error for unknown operation', () => {
-      let settings = {
-        keymaps: {
-          a: { 'type': 'scroll.home' },
-          b: { 'type': 'poison.dressing' },
-        }
-      };
-      let fn = validate.bind(undefined, settings)
-      expect(fn).to.throw(Error, 'poison.dressing');
-    });
-  });
-
-  describe("search settings", () => {
-    it('throws an error for invalid search engine name', () => {
-      let settings = {
-        search: {
-          default: 'google',
-          engines: {
-            'google': 'https://google.com/search?q={}',
-            'cherry pie': 'https://cherypie.com/search?q={}',
-          }
-        }
-      };
-      let fn = validate.bind(undefined, settings)
-      expect(fn).to.throw(Error, 'cherry pie');
-    });
-
-    it('throws an error for no {}-placeholder', () => {
-      let settings = {
-        search: {
-          default: 'google',
-          engines: {
-            'google': 'https://google.com/search?q={}',
-            'yahoo': 'https://search.yahoo.com/search',
-          }
-        }
-      };
-      let fn = validate.bind(undefined, settings)
-      expect(fn).to.throw(Error, 'yahoo');
-    });
-
-    it('throws an error for no default engines', () => {
-      let settings = {
-        search: {
-          engines: {
-            'google': 'https://google.com/search?q={}',
-            'yahoo': 'https://search.yahoo.com/search?q={}',
-          }
-        }
-      };
-      let fn = validate.bind(undefined, settings)
-      expect(fn).to.throw(Error, 'Default engine');
-    });
-
-    it('throws an error for invalid default engine', () => {
-      let settings = {
-        search: {
-          default: 'twitter',
-          engines: {
-            'google': 'https://google.com/search?q={}',
-            'yahoo': 'https://search.yahoo.com/search?q={}',
-          }
-        }
-      };
-      let fn = validate.bind(undefined, settings)
-      expect(fn).to.throw(Error, 'twitter');
-    });
-  });
-});
diff --git a/test/shared/settings/values.test.ts b/test/shared/settings/values.test.ts
deleted file mode 100644
index c72824d..0000000
--- a/test/shared/settings/values.test.ts
+++ /dev/null
@@ -1,138 +0,0 @@
-import * as values from 'shared/settings/values';
-
-describe("settings values", () => {
-  describe('valueFromJson', () => {
-    it('return object from json string', () => {
-      let json = `{
-        "keymaps": { "0": {"type": "scroll.home"}},
-        "search": { "default": "google", "engines": { "google": "https://google.com/search?q={}" }},
-        "blacklist": [ "*.slack.com"],
-        "properties": {
-          "mystr": "value",
-          "mynum": 123,
-          "mybool": true
-        }
-      }`;
-      let value = values.valueFromJson(json);
-
-      expect(value.keymaps).to.deep.equal({ 0: {type: "scroll.home"}});
-      expect(value.search).to.deep.equal({ default: "google", engines: { google: "https://google.com/search?q={}"} });
-      expect(value.blacklist).to.deep.equal(["*.slack.com"]);
-      expect(value.properties).to.have.property('mystr', 'value');
-      expect(value.properties).to.have.property('mynum', 123);
-      expect(value.properties).to.have.property('mybool', true);
-    });
-  });
-
-  describe('valueFromForm', () => {
-    it('returns value from form', () => {
-      let form = {
-        keymaps: {
-          'scroll.vertically?{"count":1}': 'j',
-          'scroll.home': '0',
-        },
-        search: {
-          default: 'google',
-          engines: [['google', 'https://google.com/search?q={}']],
-        },
-        blacklist: ['*.slack.com'],
-        "properties": {
-          "mystr": "value",
-          "mynum": 123,
-          "mybool": true,
-        }
-      };
-      let value = values.valueFromForm(form);
-
-      expect(value.keymaps).to.have.deep.property('j', { type: "scroll.vertically", count: 1 });
-      expect(value.keymaps).to.have.deep.property('0', { type: "scroll.home" });
-      expect(JSON.stringify(value.search)).to.deep.equal(JSON.stringify({ default: "google", engines: { google: "https://google.com/search?q={}"} }));
-      expect(value.search).to.deep.equal({ default: "google", engines: { google: "https://google.com/search?q={}"} });
-      expect(value.blacklist).to.deep.equal(["*.slack.com"]);
-      expect(value.properties).to.have.property('mystr', 'value');
-      expect(value.properties).to.have.property('mynum', 123);
-      expect(value.properties).to.have.property('mybool', true);
-    });
-
-    it('convert from empty form', () => {
-      let form = {};
-      let value = values.valueFromForm(form);
-      expect(value).to.not.have.key('keymaps');
-      expect(value).to.not.have.key('search');
-      expect(value).to.not.have.key('blacklist');
-      expect(value).to.not.have.key('properties');
-    });
-
-    it('override keymaps', () => {
-      let form = {
-        keymaps: {
-          'scroll.vertically?{"count":1}': 'j',
-          'scroll.vertically?{"count":-1}': 'j',
-        }
-      };
-      let value = values.valueFromForm(form);
-
-      expect(value.keymaps).to.have.key('j');
-    });
-
-    it('override search engine', () => {
-      let form = {
-        search: {
-          default: 'google',
-          engines: [
-            ['google', 'https://google.com/search?q={}'],
-            ['google', 'https://google.co.jp/search?q={}'],
-          ]
-        }
-      };
-      let value = values.valueFromForm(form);
-
-      expect(value.search.engines).to.have.property('google', 'https://google.co.jp/search?q={}');
-    });
-  });
-
-  describe('jsonFromValue', () => {
-  });
-
-  describe('formFromValue', () => {
-    it('convert empty value to form', () => {
-      let value = {};
-      let form = values.formFromValue(value);
-
-      expect(value).to.not.have.key('keymaps');
-      expect(value).to.not.have.key('search');
-      expect(value).to.not.have.key('blacklist');
-    });
-
-    it('convert value to form', () => {
-      let value = {
-        keymaps: {
-          j: { type: 'scroll.vertically', count: 1 },
-          JJ: { type: 'scroll.vertically', count: 100 },
-          0: { type: 'scroll.home' },
-        },
-        search: { default: 'google', engines: { google: 'https://google.com/search?q={}' }},
-        blacklist: [ '*.slack.com'],
-        properties: {
-          "mystr": "value",
-          "mynum": 123,
-          "mybool": true,
-        }
-      };
-      let allowed = ['scroll.vertically?{"count":1}', 'scroll.home' ];
-      let form = values.formFromValue(value, allowed);
-
-      expect(form.keymaps).to.have.property('scroll.vertically?{"count":1}', 'j');
-      expect(form.keymaps).to.not.have.property('scroll.vertically?{"count":100}');
-      expect(form.keymaps).to.have.property('scroll.home', '0');
-      expect(Object.keys(form.keymaps)).to.have.lengthOf(2);
-      expect(form.search).to.have.property('default', 'google');
-      expect(form.search).to.have.deep.property('engines', [['google', 'https://google.com/search?q={}']]);
-      expect(form.blacklist).to.have.lengthOf(1);
-      expect(form.blacklist).to.include('*.slack.com');
-      expect(form.properties).to.have.property('mystr', 'value');
-      expect(form.properties).to.have.property('mynum', 123);
-      expect(form.properties).to.have.property('mybool', true);
-    });
-  });
-});