jab2870/Vim-Vixen
Archived
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

Declare setting types

Browse source
This commit is contained in:
Shin'ya Ueoka 2019-05-05 08:03:29 +09:00
parent d01db82c0d
commit a0882bbceb
48 changed files with 1618 additions and 903 deletions
Download patch file Download diff file Expand all files Collapse all files

41
test/background/usecases/parsers.test.ts
View file

@ -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');
});
});
});

48
test/content/actions/setting.test.ts
View file

@ -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' });
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;
});
it('converts keymaps', () => {
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.settings.properties.hintchars).to.equal('abcd1234');
});
it('overrides cancel keys', () => {
let action = settingActions.set({
keymaps: {
"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' },
});
});
});
});

21
test/content/reducers/setting.test.ts
View file

@ -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' }},
]);
});
});

14
test/settings/components/form/KeymapsForm.test.tsx
View file

@ -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);
});

60
test/settings/components/form/SearchEngineForm.test.tsx
View file

@ -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();

3
test/settings/reducers/setting.test.ts
View file

@ -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', '');
});

293
test/shared/SettingData.test.ts Normal file
View file

@ -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');
});
});
});
});

190
test/shared/Settings.test.ts Normal file
View file

@ -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;
});
});
});

18
test/shared/properties.test.js Normal file
View file

@ -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');
});
});
});

18
test/shared/property-defs.test.js Normal file
View file

@ -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');
});
});
});

81
test/shared/settings/validator.test.ts
View file

@ -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');
});
});
});

138
test/shared/settings/values.test.ts
View file

@ -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);
});
});
});