Merge pull request #142 from ueokande/find-mode

[WIP] Find mode

src/background/actions/operation.js

@@ -65,6 +65,10 @@ const exec = (operation, tab) => {
     return sendConsoleShowCommand(tab, 'winopen ');
   case operations.COMMAND_SHOW_BUFFER:
     return sendConsoleShowCommand(tab, 'buffer ');
+  case operations.FIND_START:
+    return browser.tabs.sendMessage(tab.id, {
+      type: messages.CONSOLE_SHOW_FIND
+    });
   default:
     return Promise.resolve();
   }

src/background/components/background.js

@@ -34,11 +34,7 @@ export default class BackgroundComponent {
       }
       return this.store.dispatch(
         tabActions.openToTab(message.url, sender.tab), sender);
-    case messages.CONSOLE_BLURRED:
+    case messages.CONSOLE_ENTER_COMMAND:
-      return browser.tabs.sendMessage(sender.tab.id, {
-        type: messages.CONSOLE_HIDE_COMMAND,
-      });
-    case messages.CONSOLE_ENTERED:
       return commands.exec(message.text, settings.value).catch((e) => {
         return browser.tabs.sendMessage(sender.tab.id, {
           type: messages.CONSOLE_SHOW_ERROR,

src/console/actions/console.js

@@ -7,6 +7,12 @@ const showCommand = (text) => {
   };
 };
 
+const showFind = () => {
+  return {
+    type: actions.CONSOLE_SHOW_FIND,
+  };
+};
+
 const showError = (text) => {
   return {
     type: actions.CONSOLE_SHOW_ERROR,
@@ -27,10 +33,18 @@ const hideCommand = () => {
   };
 };
 
-const setCompletions = (completions) => {
+const setConsoleText = (consoleText) => {
+  return {
+    type: actions.CONSOLE_SET_CONSOLE_TEXT,
+    consoleText,
+  };
+};
+
+const setCompletions = (completionSource, completions) => {
   return {
     type: actions.CONSOLE_SET_COMPLETIONS,
-    completions: completions
+    completionSource,
+    completions,
   };
 };
 
@@ -47,6 +61,6 @@ const completionPrev = () => {
 };
 
 export {
-  showCommand, showError, showInfo, hideCommand,
+  showCommand, showFind, showError, showInfo, hideCommand, setConsoleText,
   setCompletions, completionNext, completionPrev
 };

src/console/actions/index.js

@@ -4,7 +4,9 @@ export default {
   CONSOLE_SHOW_ERROR: 'console.show.error',
   CONSOLE_SHOW_INFO: 'console.show.info',
   CONSOLE_HIDE_COMMAND: 'console.hide.command',
+  CONSOLE_SET_CONSOLE_TEXT: 'console.set.command',
   CONSOLE_SET_COMPLETIONS: 'console.set.completions',
   CONSOLE_COMPLETION_NEXT: 'console.completion.next',
   CONSOLE_COMPLETION_PREV: 'console.completion.prev',
+  CONSOLE_SHOW_FIND: 'console.show.find',
 };

src/console/components/console.js

@@ -1,45 +1,44 @@
 import messages from 'shared/messages';
 import * as consoleActions from 'console/actions/console';
 
+const inputShownMode = (state) => {
+  return ['command', 'find'].includes(state.mode);
+};
+
 export default class ConsoleComponent {
   constructor(wrapper, store) {
     this.wrapper = wrapper;
-    this.prevState = {};
-    this.completionOrigin = '';
     this.store = store;
+    this.prevMode = '';
 
     let doc = this.wrapper.ownerDocument;
     let input = doc.querySelector('#vimvixen-console-command-input');
+
     input.addEventListener('blur', this.onBlur.bind(this));
     input.addEventListener('keydown', this.onKeyDown.bind(this));
     input.addEventListener('input', this.onInput.bind(this));
 
-    this.hideCommand();
-    this.hideMessage();
-
     store.subscribe(() => {
       this.update();
     });
+    this.update();
   }
 
   onBlur() {
-    return browser.runtime.sendMessage({
+    let state = this.store.getState();
-      type: messages.CONSOLE_BLURRED,
+    if (state.mode === 'command') {
-    });
+      this.hideCommand();
+    }
   }
 
   onKeyDown(e) {
-    let doc = this.wrapper.ownerDocument;
-    let input = doc.querySelector('#vimvixen-console-command-input');
-
     switch (e.keyCode) {
     case KeyboardEvent.DOM_VK_ESCAPE:
-      return input.blur();
+      return this.hideCommand();
     case KeyboardEvent.DOM_VK_RETURN:
-      return browser.runtime.sendMessage({
+      e.stopPropagation();
-        type: messages.CONSOLE_ENTERED,
+      e.preventDefault();
-        text: e.target.value
+      return this.onEntered(e.target.value);
-      }).then(this.onBlur);
     case KeyboardEvent.DOM_VK_TAB:
       if (e.shiftKey) {
         this.store.dispatch(consoleActions.completionPrev());
@@ -52,94 +51,105 @@ export default class ConsoleComponent {
     }
   }
 
+  onEntered(value) {
+    let state = this.store.getState();
+    if (state.mode === 'command') {
+      browser.runtime.sendMessage({
+        type: messages.CONSOLE_ENTER_COMMAND,
+        text: value,
+      });
+      this.hideCommand();
+    } else if (state.mode === 'find') {
+      this.hideCommand();
+      window.top.postMessage(JSON.stringify({
+        type: messages.CONSOLE_ENTER_FIND,
+        text: value,
+      }), '*');
+    }
+  }
+
   onInput(e) {
-    let doc = this.wrapper.ownerDocument;
+    this.store.dispatch(consoleActions.setConsoleText(e.target.value));
-    let input = doc.querySelector('#vimvixen-console-command-input');
-    this.completionOrigin = input.value;
 
+    let source = e.target.value;
     return browser.runtime.sendMessage({
       type: messages.CONSOLE_QUERY_COMPLETIONS,
-      text: e.target.value,
+      text: source,
     }).then((completions) => {
-      this.store.dispatch(consoleActions.setCompletions(completions));
+      this.store.dispatch(consoleActions.setCompletions(source, completions));
     });
   }
 
-  update() {
+  onInputShown(state) {
-    let state = this.store.getState();
+    let doc = this.wrapper.ownerDocument;
-    if (this.prevState.mode !== 'command' && state.mode === 'command') {
+    let input = doc.querySelector('#vimvixen-console-command-input');
-      this.showCommand(state.commandText);
-    } else if (state.mode !== 'command') {
-      this.hideCommand();
-    }
 
-    if (state.mode === 'error' || state.mode === 'info') {
+    input.focus();
-      this.showMessage(state.mode, state.messageText);
+    window.focus();
-    } else {
-      this.hideMessage();
-    }
 
-    if (state.groupSelection >= 0 && state.itemSelection >= 0) {
+    if (state.mode === 'command') {
-      let group = state.completions[state.groupSelection];
+      this.onInput({ target: input });
-      let item = group.items[state.itemSelection];
+    }
-      this.setCommandValue(item.content);
-    } else if (state.completions.length > 0 &&
-      JSON.stringify(this.prevState.completions) ===
-        JSON.stringify(state.completions)) {
-      // Reset input only completion groups not changed (unselected an item in
-      // completion) in order to avoid to override previous input
-      this.setCommandCompletionOrigin();
   }
 
-    this.prevState = state;
+  hideCommand() {
+    this.store.dispatch(consoleActions.hideCommand());
+    window.top.postMessage(JSON.stringify({
+      type: messages.CONSOLE_UNFOCUS,
+    }), '*');
   }
 
-  showCommand(text) {
+  update() {
-    let doc = this.wrapper.ownerDocument;
+    let state = this.store.getState();
-    let command = doc.querySelector('#vimvixen-console-command');
-    let input = doc.querySelector('#vimvixen-console-command-input');
 
-    command.style.display = 'block';
+    this.updateMessage(state);
-    input.value = text;
+    this.updateCommand(state);
-    input.focus();
+    this.updatePrompt(state);
 
-    window.focus();
+    if (this.prevMode !== state.mode && inputShownMode(state)) {
-    this.onInput({ target: input });
+      this.onInputShown(state);
+    }
+    this.prevMode = state.mode;
   }
 
-  hideCommand() {
+  updateMessage(state) {
     let doc = this.wrapper.ownerDocument;
-    let command = doc.querySelector('#vimvixen-console-command');
+    let box = doc.querySelector('.vimvixen-console-message');
-    command.style.display = 'none';
+    let display = 'none';
+    let classList = ['vimvixen-console-message'];
+
+    if (state.mode === 'error' || state.mode === 'info') {
+      display = 'block';
+      classList.push('vimvixen-console-' + state.mode);
     }
 
-  setCommandValue(value) {
+    box.className = classList.join(' ');
-    let doc = this.wrapper.ownerDocument;
+    box.style.display = display;
-    let input = doc.querySelector('#vimvixen-console-command-input');
+    box.textContent = state.messageText;
-    input.value = value;
   }
 
-  setCommandCompletionOrigin() {
+  updateCommand(state) {
     let doc = this.wrapper.ownerDocument;
+    let command = doc.querySelector('#vimvixen-console-command');
     let input = doc.querySelector('#vimvixen-console-command-input');
-    input.value = this.completionOrigin;
+
+    let display = 'none';
+    if (inputShownMode(state)) {
+      display = 'block';
     }
 
-  showMessage(mode, text) {
+    command.style.display = display;
-    let doc = this.wrapper.ownerDocument;
+    input.value = state.consoleText;
-    let error = doc.querySelector('#vimvixen-console-message');
+  }
-    error.classList.remove(
+
-      'vimvixen-console-info',
+  updatePrompt(state) {
-      'vimvixen-console-error'
+    let classList = ['vimvixen-console-command-prompt'];
-    );
+    if (inputShownMode(state)) {
-    error.classList.add('vimvixen-console-' + mode);
+      classList.push('prompt-' + state.mode);
-    error.textContent = text;
-    error.style.display = 'block';
     }
 
-  hideMessage() {
     let doc = this.wrapper.ownerDocument;
-    let error = doc.querySelector('#vimvixen-console-message');
+    let ele = doc.querySelector('.vimvixen-console-command-prompt');
-    error.style.display = 'none';
+    ele.className = classList.join(' ');
   }
 }

src/console/index.html

@@ -6,8 +6,7 @@
     <script src='console.js'></script>
   </head>
   <body class='vimvixen-console'>
-    <p id='vimvixen-console-message'
+    <p class='vimvixen-console-message'></p>
-       class='vimvixen-console-message'></p>
     <div id='vimvixen-console-command'>
       <ul id='vimvixen-console-completion' class='vimvixen-console-completion'></ul>
       <div class='vimvixen-console-command'>

src/console/index.js

@@ -18,12 +18,12 @@ const onMessage = (message) => {
   switch (message.type) {
   case messages.CONSOLE_SHOW_COMMAND:
     return store.dispatch(consoleActions.showCommand(message.command));
+  case messages.CONSOLE_SHOW_FIND:
+    return store.dispatch(consoleActions.showFind());
   case messages.CONSOLE_SHOW_ERROR:
     return store.dispatch(consoleActions.showError(message.text));
   case messages.CONSOLE_SHOW_INFO:
     return store.dispatch(consoleActions.showInfo(message.text));
-  case messages.CONSOLE_HIDE_COMMAND:
-    return store.dispatch(consoleActions.hideCommand());
   }
 };
 

src/console/reducers/index.js

@@ -3,7 +3,8 @@ import actions from 'console/actions';
 const defaultState = {
   mode: '',
   messageText: '',
-  commandText: '',
+  consoleText: '',
+  completionSource: '',
   completions: [],
   groupSelection: -1,
   itemSelection: -1,
@@ -43,13 +44,25 @@ const prevSelection = (state) => {
   return [state.groupSelection, state.itemSelection - 1];
 };
 
+const nextConsoleText = (completions, group, item, defaults) => {
+  if (group < 0 || item < 0) {
+    return defaults;
+  }
+  return completions[group].items[item].content;
+};
+
 export default function reducer(state = defaultState, action = {}) {
   switch (action.type) {
   case actions.CONSOLE_SHOW_COMMAND:
     return Object.assign({}, state, {
       mode: 'command',
-      commandText: action.text,
+      consoleText: action.text,
-      errorShown: false,
+      completions: []
+    });
+  case actions.CONSOLE_SHOW_FIND:
+    return Object.assign({}, state, {
+      mode: 'find',
+      consoleText: '',
       completions: []
     });
   case actions.CONSOLE_SHOW_ERROR:
@@ -64,11 +77,16 @@ export default function reducer(state = defaultState, action = {}) {
     });
   case actions.CONSOLE_HIDE_COMMAND:
     return Object.assign({}, state, {
-      mode: state.mode === 'command' ? '' : state.mode,
+      mode: state.mode === 'command' || state.mode === 'find' ? '' : state.mode,
+    });
+  case actions.CONSOLE_SET_CONSOLE_TEXT:
+    return Object.assign({}, state, {
+      consoleText: action.consoleText,
     });
   case actions.CONSOLE_SET_COMPLETIONS:
     return Object.assign({}, state, {
       completions: action.completions,
+      completionSource: action.completionSource,
       groupSelection: -1,
       itemSelection: -1,
     });
@@ -77,6 +95,9 @@ export default function reducer(state = defaultState, action = {}) {
     return Object.assign({}, state, {
       groupSelection: next[0],
       itemSelection: next[1],
+      consoleText: nextConsoleText(
+        state.completions, next[0], next[1],
+        state.completionSource),
     });
   }
   case actions.CONSOLE_COMPLETION_PREV: {
@@ -84,6 +105,9 @@ export default function reducer(state = defaultState, action = {}) {
     return Object.assign({}, state, {
       groupSelection: next[0],
       itemSelection: next[1],
+      consoleText: nextConsoleText(
+        state.completions, next[0], next[1],
+        state.completionSource),
     });
   }
   default:

src/console/site.scss

@@ -85,9 +85,15 @@ body {
     display: flex;
 
     &-prompt:before {
+      @include consoole-font;
+    }
+
+    &-prompt.prompt-command:before {
       content: ':';
+    }
 
-      @include consoole-font;
+    &-prompt.prompt-find:before {
+      content: '/';
     }
 
     &-input {

src/content/actions/find.js

@@ -0,0 +1,55 @@
+//
+// window.find(aString, aCaseSensitive, aBackwards, aWrapAround,
+//             aWholeWord, aSearchInFrames);
+//
+// NOTE: window.find is not standard API
+// https://developer.mozilla.org/en-US/docs/Web/API/Window/find
+
+import actions from 'content/actions';
+import * as consoleFrames from '../console-frames';
+
+const postPatternNotFound = (pattern) => {
+  return consoleFrames.postError(
+    window.document,
+    'Pattern not found: ' + pattern);
+};
+
+const find = (string, backwards) => {
+  let caseSensitive = false;
+  let wrapScan = true;
+
+
+  // NOTE: aWholeWord dows not implemented, and aSearchInFrames does not work
+  // because of same origin policy
+  return window.find(string, caseSensitive, backwards, wrapScan);
+};
+
+const findNext = (keyword, reset, backwards) => {
+  if (reset) {
+    window.getSelection().removeAllRanges();
+  }
+
+  let found = find(keyword, backwards);
+  if (!found) {
+    window.getSelection().removeAllRanges();
+    found = find(keyword, backwards);
+  }
+  if (!found) {
+    postPatternNotFound(keyword);
+  }
+  return {
+    type: actions.FIND_SET_KEYWORD,
+    keyword,
+    found,
+  };
+};
+
+const next = (keyword, reset) => {
+  return findNext(keyword, reset, false);
+};
+
+const prev = (keyword, reset) => {
+  return findNext(keyword, reset, true);
+};
+
+export { next, prev };

src/content/actions/index.js

@@ -21,4 +21,7 @@ export default {
   FOLLOW_CONTROLLER_DISABLE: 'follow.controller.disable',
   FOLLOW_CONTROLLER_KEY_PRESS: 'follow.controller.key.press',
   FOLLOW_CONTROLLER_BACKSPACE: 'follow.controller.backspace',
+
+  // Find
+  FIND_SET_KEYWORD: 'find.set.keyword',
 };

src/content/actions/operation.js

@@ -6,6 +6,7 @@ import * as urls from 'content/urls';
 import * as consoleFrames from 'content/console-frames';
 import * as addonActions from './addon';
 
+// eslint-disable-next-line complexity
 const exec = (operation) => {
   switch (operation.type) {
   case operations.ADDON_ENABLE:
@@ -14,6 +15,14 @@ const exec = (operation) => {
     return addonActions.disable();
   case operations.ADDON_TOGGLE_ENABLED:
     return addonActions.toggleEnabled();
+  case operations.FIND_NEXT:
+    return window.top.postMessage(JSON.stringify({
+      type: messages.FIND_NEXT,
+    }), '*');
+  case operations.FIND_PREV:
+    return window.top.postMessage(JSON.stringify({
+      type: messages.FIND_PREV,
+    }), '*');
   case operations.SCROLL_VERTICALLY:
     return scrolls.scrollVertically(window, operation.count);
   case operations.SCROLL_HORIZONALLY:

src/content/components/top-content/find.js

@@ -0,0 +1,54 @@
+import * as findActions from 'content/actions/find';
+import messages from 'shared/messages';
+import * as consoleFrames from '../../console-frames';
+
+export default class FindComponent {
+  constructor(win, store) {
+    this.win = win;
+    this.store = store;
+
+    messages.onMessage(this.onMessage.bind(this));
+  }
+
+  onMessage(message) {
+    switch (message.type) {
+    case messages.CONSOLE_ENTER_FIND:
+      return this.start(message.text);
+    case messages.FIND_NEXT:
+      return this.next();
+    case messages.FIND_PREV:
+      return this.prev();
+    }
+  }
+
+  start(text) {
+    let state = this.store.getState().find;
+
+    if (text.length === 0) {
+      return this.store.dispatch(findActions.next(state.keyword, true));
+    }
+    return this.store.dispatch(findActions.next(text, true));
+  }
+
+  next() {
+    let state = this.store.getState().find;
+
+    if (!state.found) {
+      return consoleFrames.postError(
+        window.document,
+        'Pattern not found: ' + state.keyword);
+    }
+    return this.store.dispatch(findActions.next(state.keyword, false));
+  }
+
+  prev() {
+    let state = this.store.getState().find;
+
+    if (!state.found) {
+      return consoleFrames.postError(
+        window.document,
+        'Pattern not found: ' + state.keyword);
+    }
+    return this.store.dispatch(findActions.prev(state.keyword, false));
+  }
+}

src/content/components/top-content/index.js

@@ -1,5 +1,6 @@
 import CommonComponent from '../common';
 import FollowController from './follow-controller';
+import FindComponent from './find';
 import * as consoleFrames from '../../console-frames';
 import * as addonActions from '../../actions/addon';
 import messages from 'shared/messages';
@@ -14,6 +15,7 @@ export default class TopContent {
 
     new CommonComponent(win, store); // eslint-disable-line no-new
     new FollowController(win, store); // eslint-disable-line no-new
+    new FindComponent(win, store); // eslint-disable-line no-new
 
     // TODO make component
     consoleFrames.initialize(this.win.document);
@@ -47,7 +49,7 @@ export default class TopContent {
 
   onMessage(message) {
     switch (message.type) {
-    case messages.CONSOLE_HIDE_COMMAND:
+    case messages.CONSOLE_UNFOCUS:
       this.win.focus();
       consoleFrames.blur(window.document);
       return Promise.resolve();

src/content/console-frames.js

@@ -1,4 +1,5 @@
 import './console-frame.scss';
+import messages from 'shared/messages';
 
 const initialize = (doc) => {
   let iframe = doc.createElement('iframe');
@@ -20,4 +21,11 @@ const postMessage = (doc, message) => {
   iframe.contentWindow.postMessage(JSON.stringify(message), '*');
 };
 
-export { initialize, blur, postMessage };
+const postError = (doc, message) => {
+  return postMessage(doc, {
+    type: messages.CONSOLE_SHOW_ERROR,
+    text: message,
+  });
+};
+
+export { initialize, blur, postMessage, postError };

src/content/reducers/find.js

@@ -0,0 +1,18 @@
+import actions from 'content/actions';
+
+const defaultState = {
+  keyword: '',
+  found: false,
+};
+
+export default function reducer(state = defaultState, action = {}) {
+  switch (action.type) {
+  case actions.FIND_SET_KEYWORD:
+    return Object.assign({}, state, {
+      keyword: action.keyword,
+      found: action.found,
+    });
+  default:
+    return state;
+  }
+}

src/content/reducers/index.js

@@ -1,4 +1,5 @@
 import addonReducer from './addon';
+import findReducer from './find';
 import settingReducer from './setting';
 import inputReducer from './input';
 import followControllerReducer from './follow-controller';
@@ -6,6 +7,7 @@ import followControllerReducer from './follow-controller';
 // Make setting reducer instead of re-use
 const defaultState = {
   addon: addonReducer(undefined, {}),
+  find: findReducer(undefined, {}),
   setting: settingReducer(undefined, {}),
   input: inputReducer(undefined, {}),
   followController: followControllerReducer(undefined, {}),
@@ -14,6 +16,7 @@ const defaultState = {
 export default function reducer(state = defaultState, action = {}) {
   return Object.assign({}, state, {
     addon: addonReducer(state.addon, action),
+    find: findReducer(state.find, action),
     setting: settingReducer(state.setting, action),
     input: inputReducer(state.input, action),
     followController: followControllerReducer(state.followController, action),

src/shared/default-settings.js

@@ -46,6 +46,9 @@ export default {
     "gu": { "type": "navigate.parent" },
     "gU": { "type": "navigate.root" },
     "y": { "type": "urls.yank" },
+    "/": { "type": "find.start" },
+    "n": { "type": "find.next" },
+    "N": { "type": "find.prev" },
     "<S-Esc>": { "type": "addon.toggle.enabled" }
   },
   "search": {

src/shared/messages.js

@@ -24,13 +24,14 @@ const onMessage = (listener) => {
 export default {
   BACKGROUND_OPERATION: 'background.operation',
 
-  CONSOLE_BLURRED: 'console.blured',
+  CONSOLE_UNFOCUS: 'console.unfocus',
-  CONSOLE_ENTERED: 'console.entered',
+  CONSOLE_ENTER_COMMAND: 'console.enter.command',
+  CONSOLE_ENTER_FIND: 'console.enter.find',
   CONSOLE_QUERY_COMPLETIONS: 'console.query.completions',
   CONSOLE_SHOW_COMMAND: 'console.show.command',
   CONSOLE_SHOW_ERROR: 'console.show.error',
   CONSOLE_SHOW_INFO: 'console.show.info',
-  CONSOLE_HIDE_COMMAND: 'console.hide.command',
+  CONSOLE_SHOW_FIND: 'console.show.find',
 
   FOLLOW_START: 'follow.start',
   FOLLOW_REQUEST_COUNT_TARGETS: 'follow.request.count.targets',
@@ -41,6 +42,9 @@ export default {
   FOLLOW_ACTIVATE: 'follow.activate',
   FOLLOW_KEY_PRESS: 'follow.key.press',
 
+  FIND_NEXT: 'find.next',
+  FIND_PREV: 'find.prev',
+
   OPEN_URL: 'open.url',
 
   SETTINGS_RELOAD: 'settings.reload',

src/shared/operations.js

@@ -51,4 +51,9 @@ export default {
 
   // Url yank
   URLS_YANK: 'urls.yank',
+
+  // Find
+  FIND_START: 'find.start',
+  FIND_NEXT: 'find.next',
+  FIND_PREV: 'find.prev',
 };

test/console/actions/console.test.js

@@ -11,6 +11,13 @@ describe("console actions", () => {
     });
   });
 
+  describe("showFind", () => {
+    it('create CONSOLE_SHOW_FIND action', () => {
+      let action = consoleActions.showFind();
+      expect(action.type).to.equal(actions.CONSOLE_SHOW_FIND);
+    });
+  });
+
   describe("showInfo", () => {
     it('create CONSOLE_SHOW_INFO action', () => {
       let action = consoleActions.showInfo('an info');
@@ -27,17 +34,26 @@ describe("console actions", () => {
     });
   });
 
-  describe("hide", () => {
+  describe("hideCommand", () => {
     it('create CONSOLE_HIDE_COMMAND action', () => {
       let action = consoleActions.hideCommand();
       expect(action.type).to.equal(actions.CONSOLE_HIDE_COMMAND);
     });
   });
 
+  describe('setConsoleText', () => {
+    it('create CONSOLE_SET_CONSOLE_TEXT action', () => {
+      let action = consoleActions.setConsoleText('hello world');
+      expect(action.type).to.equal(actions.CONSOLE_SET_CONSOLE_TEXT);
+      expect(action.consoleText).to.equal('hello world');
+    });
+  });
+
   describe("setCompletions", () => {
     it('create CONSOLE_SET_COMPLETIONS action', () => {
-      let action = consoleActions.setCompletions([1,2,3]);
+      let action = consoleActions.setCompletions('query', [1, 2, 3]);
       expect(action.type).to.equal(actions.CONSOLE_SET_COMPLETIONS);
+      expect(action.completionSource).to.deep.equal('query');
       expect(action.completions).to.deep.equal([1, 2, 3]);
     });
   });
@@ -56,4 +72,3 @@ describe("console actions", () => {
     });
   });
 });
-

test/console/reducers/console.test.js

@@ -7,7 +7,7 @@ describe("console reducer", () => {
     let state = reducer(undefined, {});
     expect(state).to.have.property('mode', '');
     expect(state).to.have.property('messageText', '');
-    expect(state).to.have.property('commandText', '');
+    expect(state).to.have.property('consoleText', '');
     expect(state).to.have.deep.property('completions', []);
     expect(state).to.have.property('groupSelection', -1);
     expect(state).to.have.property('itemSelection', -1);
@@ -17,7 +17,7 @@ describe("console reducer", () => {
     let action = { type: actions.CONSOLE_SHOW_COMMAND, text: 'open ' };
     let state = reducer({}, action);
     expect(state).to.have.property('mode', 'command');
-    expect(state).to.have.property('commandText', 'open ');
+    expect(state).to.have.property('consoleText', 'open ');
   });
 
   it('return next state for CONSOLE_SHOW_INFO', () => {
@@ -43,6 +43,16 @@ describe("console reducer", () => {
     expect(state).to.have.property('mode', 'error');
   });
 
+  it('return next state for CONSOLE_SET_CONSOLE_TEXT', () => {
+    let action = {
+      type: actions.CONSOLE_SET_CONSOLE_TEXT,
+      consoleText: 'hello world'
+    }
+    let state = reducer({}, action)
+
+    expect(state).to.have.property('consoleText', 'hello world');
+  });
+
   it ('return next state for CONSOLE_SET_COMPLETIONS', () => {
     let state = {
       groupSelection: 0,

test/content/reducers/find.test.js

@@ -0,0 +1,23 @@
+import { expect } from "chai";
+import actions from 'content/actions';
+import findReducer from 'content/reducers/find';
+
+describe("find reducer", () => {
+  it('return the initial state', () => {
+    let state = findReducer(undefined, {});
+    expect(state).to.have.property('keyword', '');
+    expect(state).to.have.property('found', false);
+  });
+
+  it('return next state for FIND_SET_KEYWORD', () => {
+    let action = {
+      type: actions.FIND_SET_KEYWORD,
+      keyword: 'xyz',
+      found: true,
+    };
+    let state = findReducer({}, action);
+
+    expect(state.keyword).is.equal('xyz');
+    expect(state.found).to.be.true;
+  });
+});