Type InputHandler tests

src/Buffer.test.ts

@@ -1,6 +1,7 @@
 /**
  * @license MIT
  */
+
 import { assert } from 'chai';
 import { ITerminal } from './Interfaces';
 import { Buffer } from './Buffer';

src/BufferSet.test.ts

@@ -1,6 +1,7 @@
 /**
  * @license MIT
  */
+
 import { assert } from 'chai';
 import { ITerminal } from './Interfaces';
 import { BufferSet } from './BufferSet';

src/CompositionHelper.test.ts

@@ -1,3 +1,7 @@
+/**
+ * @license MIT
+ */
+
 import { assert } from 'chai';
 import { CompositionHelper } from './CompositionHelper';
 

src/EventEmitter.test.ts

@@ -1,3 +1,7 @@
+/**
+ * @license MIT
+ */
+
 import { assert } from 'chai';
 import { EventEmitter } from './EventEmitter';
 

src/InputHandler.test.ts

@@ -1,12 +1,18 @@
+/**
+ * @license MIT
+ */
+
 import { assert } from 'chai';
 import { InputHandler } from './InputHandler';
 import { wcwidth } from './InputHandler';
+import { MockInputHandlingTerminal } from './utils/TestUtils';
 
 describe('InputHandler', () => {
   describe('save and restore cursor', () => {
-    let terminal = { buffer: { x: 1, y: 2 } };
-    // TODO: Create proper mock IInputHandlingTerminal test util object
-    let inputHandler = new InputHandler(<any>terminal);
+    let terminal = new MockInputHandlingTerminal();
+    terminal.buffer.x = 1;
+    terminal.buffer.y = 2;
+    let inputHandler = new InputHandler(terminal);
     // Save cursor position
     inputHandler.saveCursor([]);
     assert.equal(terminal.buffer.x, 1);
@@ -21,46 +27,42 @@ describe('InputHandler', () => {
   });
   describe('setCursorStyle', () => {
     it('should call Terminal.setOption with correct params', () => {
-      let options = {};
-      let terminal = {
-        setOption: (option, value) => options[option] = value
-      };
-      let inputHandler = new InputHandler(<any>terminal);
+      let terminal = new MockInputHandlingTerminal();
+      let inputHandler = new InputHandler(terminal);
 
       inputHandler.setCursorStyle([0]);
-      assert.equal(options['cursorStyle'], 'block');
-      assert.equal(options['cursorBlink'], true);
+      assert.equal(terminal.options['cursorStyle'], 'block');
+      assert.equal(terminal.options['cursorBlink'], true);
 
-      options = {};
+      terminal.options = {};
       inputHandler.setCursorStyle([1]);
-      assert.equal(options['cursorStyle'], 'block');
-      assert.equal(options['cursorBlink'], true);
+      assert.equal(terminal.options['cursorStyle'], 'block');
+      assert.equal(terminal.options['cursorBlink'], true);
 
-      options = {};
+      terminal.options = {};
       inputHandler.setCursorStyle([2]);
-      assert.equal(options['cursorStyle'], 'block');
-      assert.equal(options['cursorBlink'], false);
+      assert.equal(terminal.options['cursorStyle'], 'block');
+      assert.equal(terminal.options['cursorBlink'], false);
 
-      options = {};
+      terminal.options = {};
       inputHandler.setCursorStyle([3]);
-      assert.equal(options['cursorStyle'], 'underline');
-      assert.equal(options['cursorBlink'], true);
+      assert.equal(terminal.options['cursorStyle'], 'underline');
+      assert.equal(terminal.options['cursorBlink'], true);
 
-      options = {};
+      terminal.options = {};
       inputHandler.setCursorStyle([4]);
-      assert.equal(options['cursorStyle'], 'underline');
-      assert.equal(options['cursorBlink'], false);
+      assert.equal(terminal.options['cursorStyle'], 'underline');
+      assert.equal(terminal.options['cursorBlink'], false);
 
-      options = {};
+      terminal.options = {};
       inputHandler.setCursorStyle([5]);
-      assert.equal(options['cursorStyle'], 'bar');
-      assert.equal(options['cursorBlink'], true);
+      assert.equal(terminal.options['cursorStyle'], 'bar');
+      assert.equal(terminal.options['cursorBlink'], true);
 
-      options = {};
+      terminal.options = {};
       inputHandler.setCursorStyle([6]);
-      assert.equal(options['cursorStyle'], 'bar');
-      assert.equal(options['cursorBlink'], false);
-
+      assert.equal(terminal.options['cursorStyle'], 'bar');
+      assert.equal(terminal.options['cursorBlink'], false);
     });
   });
 });

src/InputHandler.ts

@@ -15,7 +15,6 @@ import { CharData } from './Types';
  * each function's header comment.
  */
 export class InputHandler implements IInputHandler {
-  // TODO: We want to type _terminal when it's pulled into TS
   constructor(private _terminal: IInputHandlingTerminal) { }
 
   public addChar(char: string, code: number): void {

src/Linkifier.test.ts

@@ -1,6 +1,7 @@
 /**
  * @license MIT
  */
+
 import jsdom = require('jsdom');
 import { assert } from 'chai';
 import { ITerminal, ILinkifier } from './Interfaces';

src/SelectionManager.test.ts

@@ -1,6 +1,7 @@
 /**
  * @license MIT
  */
+
 import jsdom = require('jsdom');
 import { assert } from 'chai';
 import { ITerminal, ICircularList } from './Interfaces';

src/SelectionModel.test.ts

@@ -1,6 +1,7 @@
 /**
  * @license MIT
  */
+
 import { assert } from 'chai';
 import { ITerminal } from './Interfaces';
 import { SelectionModel } from './SelectionModel';

src/Viewport.test.ts

@@ -1,3 +1,7 @@
+/**
+ * @license MIT
+ */
+
 import { assert } from 'chai';
 import { Viewport } from './Viewport';
 import {BufferSet} from './BufferSet';

src/utils/CharMeasure.test.ts

@@ -1,6 +1,7 @@
 /**
  * @license MIT
  */
+
 import jsdom = require('jsdom');
 import { assert } from 'chai';
 import { ICharMeasure, ITerminal } from '../Interfaces';

src/utils/CircularList.test.ts

@@ -1,3 +1,7 @@
+/**
+ * @license MIT
+ */
+
 import { assert } from 'chai';
 import { CircularList } from './CircularList';
 

src/utils/CircularList.ts

@@ -4,6 +4,7 @@
  * @module xterm/utils/CircularList
  * @license MIT
  */
+
 import { EventEmitter } from '../EventEmitter';
 import { ICircularList } from '../Interfaces';
 

src/utils/DomElementObjectPool.test.ts

@@ -1,3 +1,7 @@
+/**
+ * @license MIT
+ */
+
 import { assert } from 'chai';
 import { DomElementObjectPool } from './DomElementObjectPool';
 

src/utils/TestUtils.ts

@@ -1,4 +1,8 @@
-import { ITerminal, IBuffer, IBufferSet, IBrowser, ICharMeasure, ISelectionManager, ITerminalOptions, IListenerType } from '../Interfaces';
+/**
+ * @license MIT
+ */
+
+import { ITerminal, IBuffer, IBufferSet, IBrowser, ICharMeasure, ISelectionManager, ITerminalOptions, IListenerType, IInputHandlingTerminal, IViewport, ICircularList } from '../Interfaces';
 import { LineData } from '../Types';
 
 export class MockTerminal implements ITerminal {
@@ -20,7 +24,6 @@ export class MockTerminal implements ITerminal {
   scrollback: number;
   buffers: IBufferSet;
   buffer: IBuffer;
-
   handler(data: string): void {
     throw new Error('Method not implemented.');
   }
@@ -56,3 +59,125 @@ export class MockTerminal implements ITerminal {
     return line;
   }
 }
+
+export class MockInputHandlingTerminal implements IInputHandlingTerminal {
+  element: HTMLElement;
+  options: ITerminalOptions = {};
+  cols: number;
+  rows: number;
+  charset: { [key: string]: string; };
+  gcharset: number;
+  glevel: number;
+  charsets: { [key: string]: string; }[];
+  applicationKeypad: boolean;
+  applicationCursor: boolean;
+  originMode: boolean;
+  insertMode: boolean;
+  wraparoundMode: boolean;
+  defAttr: number;
+  curAttr: number;
+  prefix: string;
+  savedCols: number;
+  x10Mouse: boolean;
+  vt200Mouse: boolean;
+  normalMouse: boolean;
+  mouseEvents: boolean;
+  sendFocus: boolean;
+  utfMouse: boolean;
+  sgrMouse: boolean;
+  urxvtMouse: boolean;
+  cursorHidden: boolean;
+  buffers: IBufferSet;
+  buffer: IBuffer = new MockBuffer();
+  viewport: IViewport;
+  selectionManager: ISelectionManager;
+  focus(): void {
+    throw new Error('Method not implemented.');
+  }
+  convertEol: boolean;
+  updateRange(y: number): void {
+    throw new Error('Method not implemented.');
+  }
+  scroll(isWrapped?: boolean): void {
+    throw new Error('Method not implemented.');
+  }
+  nextStop(x?: number): number {
+    throw new Error('Method not implemented.');
+  }
+  setgLevel(g: number): void {
+    throw new Error('Method not implemented.');
+  }
+  eraseAttr() {
+    throw new Error('Method not implemented.');
+  }
+  eraseRight(x: number, y: number): void {
+    throw new Error('Method not implemented.');
+  }
+  eraseLine(y: number): void {
+    throw new Error('Method not implemented.');
+  }
+  eraseLeft(x: number, y: number): void {
+    throw new Error('Method not implemented.');
+  }
+  blankLine(cur?: boolean, isWrapped?: boolean): [number, string, number][] {
+    throw new Error('Method not implemented.');
+  }
+  prevStop(x?: number): number {
+    throw new Error('Method not implemented.');
+  }
+  is(term: string): boolean {
+    throw new Error('Method not implemented.');
+  }
+  send(data: string): void {
+    throw new Error('Method not implemented.');
+  }
+  setgCharset(g: number, charset: { [key: string]: string; }): void {
+    throw new Error('Method not implemented.');
+  }
+  resize(x: number, y: number): void {
+    throw new Error('Method not implemented.');
+  }
+  log(text: string, data?: any): void {
+    throw new Error('Method not implemented.');
+  }
+  reset(): void {
+    throw new Error('Method not implemented.');
+  }
+  showCursor(): void {
+    throw new Error('Method not implemented.');
+  }
+  refresh(start: number, end: number): void {
+    throw new Error('Method not implemented.');
+  }
+  matchColor(r1: number, g1: number, b1: number) {
+    throw new Error('Method not implemented.');
+  }
+  error(text: string, data?: any): void {
+    throw new Error('Method not implemented.');
+  }
+  setOption(key: string, value: any): void {
+    this.options[key] = value;
+  }
+  on(type: string, listener: IListenerType): void {
+    throw new Error('Method not implemented.');
+  }
+  off(type: string, listener: IListenerType): void {
+    throw new Error('Method not implemented.');
+  }
+  emit(type: string, data?: any): void {
+    throw new Error('Method not implemented.');
+  }
+}
+
+export class MockBuffer implements IBuffer {
+  lines: ICircularList<[number, string, number][]>;
+  ydisp: number;
+  ybase: number;
+  y: number;
+  x: number;
+  tabs: any;
+  scrollBottom: number;
+  scrollTop: number;
+  savedY: number;
+  savedX: number;
+}

src/xterm.ts

@@ -1,3 +1,7 @@
+/**
+ * @license MIT
+ */
+
 import { Terminal } from './Terminal';
 
 module.exports = Terminal;