chore(ls): add unit tests to the server (#20)

Author: chuckjaz

scripts/ci/test.sh

@@ -4,6 +4,13 @@ set -ex -o pipefail
 
 echo 'travis_fold:start:TEST'
 
+# Server unit tests
+(
+  cd server
+  npm run test
+)
+
+# Server smoke test
 tests/tests.sh
 
 echo 'travis_fold:end:TEST'

server/.vscode/launch.json

@@ -10,7 +10,7 @@
       "outDir": "${workspaceRoot}/../client/server"
     },
     {
-      "name": "Attach (cmd)",
+      "name": "Attach (tests)",
       "type": "node",
       "request": "attach",
       "port": 5858,

server/package.json

@@ -8,8 +8,9 @@
     "node": "*"
   },
   "scripts": {
-    "compile": "installServerIntoExtension ../client ./package.json ./tsconfig.json && tsc -p .",
-    "watch": "installServerIntoExtension ../client ./package.json ./tsconfig.json && tsc --watch -p ."
+    "compile": "installServerIntoExtension ../client ./package.json ./tsconfig-build.json && tsc -p tsconfig-build.json",
+    "watch": "installServerIntoExtension ../client ./package.json ./tsconfig.json && tsc --watch -p tsconfig-build.json",
+    "test": "tsc -p . && jasmine -- dist/**/*_spec.js"
   },
   "dependencies": {
     "@angular/language-service": "^2.3.1",
@@ -21,7 +22,9 @@
     "@angular/compiler": "^2.3.1",
     "@angular/compiler-cli": "^2.3.1",
     "@angular/core": "^2.3.1",
+    "@types/jasmine": "^2.5.38",
     "@types/node": "^6.0.46",
+    "jasmine": "^2.5.2",
     "rxjs": "5.0.0-rc.4",
     "zone.js": "^0.7.2"
   },

server/src/editorServices.ts

@@ -33,8 +33,8 @@ export interface ProjectServiceHost {
   resolvePath(path: string): string;
   fileExists(path: string): boolean;
   getDirectories(path: string): string[];
-  watchDirectory?(path: string, callback: ts.DirectoryWatcherCallback, recursive?: boolean): ts.FileWatcher;
-  watchFile?(path: string, callback: ts.FileWatcherCallback): ts.FileWatcher;
+  watchDirectory(path: string, callback: ts.DirectoryWatcherCallback, recursive?: boolean): ts.FileWatcher;
+  watchFile(path: string, callback: ts.FileWatcherCallback): ts.FileWatcher;
   readDirectory(path: string, extensions?: string[], exclude?: string[], include?: string[]): string[];
 
   useCaseSensitiveFileNames: boolean;

server/tests/editorServices_spec.ts

@@ -0,0 +1,99 @@
+/// <reference path="../node_modules/@types/jasmine/index.d.ts" />
+
+import * as ts from 'typescript';
+import {LineIndexSnapshot, Logger, ProjectService, ProjectServiceHost, ScriptInfo} from '../src/editorServices';
+
+import * as u from './test_utils';
+import {QUICKSTART} from './test_data';
+
+describe('editor services', () => {
+  let projectService: ProjectService;
+  beforeAll(() => {
+    projectService = new ProjectService(new u.MockProjectServiceHost(QUICKSTART), new u.MockLogger());
+  });
+
+  it('should be able to get the information for a file', () => {
+    projectService.openClientFile('/app/app.component.ts');
+    const info = projectService.getScriptInfo('/app/app.component.ts');
+    expect(info).not.toBeUndefined();
+  });
+
+  describe('file', () => {
+    function tests(fileName: string, content: string) {
+      let info: ScriptInfo;
+      let snap: LineIndexSnapshot;
+      let len: number;
+
+      beforeEach(() => {
+        projectService.openClientFile(fileName, content);
+        info = projectService.getScriptInfo(fileName);
+        snap = info.snap();
+        len = snap.getLength();
+      })
+
+      it('should be able to get pieces of a file', () => {
+        const firstText = snap.getText(0, len);
+        for (let i = 0; i < len; i++) {
+          expect(snap.getText(i, i + 1)).toEqual(firstText[i]);
+        }
+      });
+
+      it('should be able to modify the file and get the expected content', () => {
+        const offsetOfComponent = content.indexOf('@Component');
+        projectService.clientFileChanges(fileName, [{start: offsetOfComponent, end: offsetOfComponent, insertText: ' '}]);
+        const text = info.getText();
+        expect(text).toEqual(content.replace('@Component', ' @Component'));
+      });
+
+      describe('and line starts', () => {
+        let lineStarts: number[];
+
+        beforeAll(() => {
+          lineStarts = getLineStarts(content);
+        });
+
+        it('should be able to get the expected line columns', () => {
+          for (let i = 0; i < len; i++) {
+            const expected = lineColOf(i, lineStarts);
+            const result = projectService.positionsToLineOffsets(fileName, [i]);
+            expect(result).toEqual([expected]);
+          }
+        });
+
+        it('should be able to turn line columns in offsets', () => {
+          for (let i = 0; i < len; i++) {
+            const expected = lineColOf(i, lineStarts);
+            const result = projectService.lineOffsetsToPositions(fileName, [expected]);
+            expect(result).toEqual([i]);
+          }
+        });
+      });
+    }
+
+    const fileName = '/app/app.component.ts';
+    describe('with LF', () => {
+      tests(fileName, u.read(fileName, QUICKSTART));
+    });
+    describe('with LF/CR', () => {
+      tests(fileName, u.read(fileName, QUICKSTART).replace(/\n/g, '\r\n'));
+    });
+  });
+});
+
+function getLineStarts(content: string): number[] {
+  const result = [0];
+  const len = content.length;
+  for (let i = 0; i < len; i++) {
+    if (content[i] == `\n`) result.push(i + 1);
+  }
+  result.push(len);
+  return result;
+}
+
+function lineColOf(position: number, lineStarts: number[]) {
+  for (let line = 0; line < lineStarts.length; line++) {
+    if (lineStarts[line + 1] > position) {
+      return {line: line + 1, col: position - lineStarts[line] + 1};
+    }
+  }
+}

server/tests/test_data.ts

@@ -0,0 +1,52 @@
+import {MockData} from './test_utils';
+
+export const QUICKSTART: MockData = {
+  'tsconfig.json': `
+{
+  "compilerOptions": {
+    "target": "es5",
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "sourceMap": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "lib": [ "es2015", "dom" ],
+    "noImplicitAny": true,
+    "suppressImplicitAnyIndexErrors": true
+  }
+}
+`,
+  'app': {
+
+    'app.component.ts': `
+import { Component } from '@angular/core';
+
+@Component({
+  selector: 'my-app',
+  template: \`<h1>Hello  {{name}}</h1> ><div *ngIf="name !== undefined"></div>\`,
+})
+export class AppComponent  { name = 'Angular'; }`,
+
+
+    'app.module.ts': `
+import { NgModule }      from '@angular/core';
+import { BrowserModule } from '@angular/platform-browser';
+
+import { AppComponent }  from './app.component';
+
+@NgModule({
+  imports:      [ BrowserModule ],
+  declarations: [ AppComponent ],
+  bootstrap:    [ AppComponent ]
+})
+export class AppModule { } `,
+
+
+    'main.ts': `
+import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
+
+import { AppModule } from './app.module';
+
+platformBrowserDynamic().bootstrapModule(AppModule);`,
+  }
+};

server/tests/test_utils.ts

@@ -0,0 +1,76 @@
+import * as ts from 'typescript';
+import {Logger, ProjectServiceHost} from '../src/editorServices';
+
+export type MockData = string | MockDirectory;
+
+export type MockDirectory = {
+  [name: string]: MockData | undefined;
+}
+
+export function find(fileName: string, data: MockData): MockData|undefined {
+  const names = fileName.split('/');
+  if (names.length && !names[0].length) names.shift();
+  let current = data;
+  for (let name of names) {
+    if (typeof current === 'string') {
+      return undefined;
+    } else {
+      current = (current as MockDirectory)[name];
+    }
+    if (!current) return undefined;
+  }
+  return current;
+}
+
+export function read(fileName: string, data: MockData): string|undefined {
+  const result = find(fileName, data);
+  if (typeof result === 'string') {
+    return result;
+  }
+  return undefined;
+}
+
+export function fileExists(fileName: string, data: MockData): boolean {
+  let result = find(fileName, data);
+  return result && typeof result == 'string';
+}
+
+export function directoryExists(dirname: string, data: MockData): boolean {
+  let result = find(dirname, data);
+  return result && typeof result !== 'string';
+}
+
+export function getDirectories(path: string, data: MockData): string[] {
+  let result = find(path, data);
+  return result && typeof result !== 'string' && Object.keys(result);
+}
+
+export class MockProjectServiceHost implements ProjectServiceHost {
+  constructor(private data: MockData) {}
+  getCurrentDirectory(): string { return "/"; }
+  readFile(path: string, encoding?: string): string { return read(path, this.data); }
+  directoryExists(path: string): boolean { return directoryExists(path, this.data); }
+  getExecutingFilePath(): string { return "/"; }
+  resolvePath(path: string): string { return path; }
+  fileExists(path: string): boolean { return fileExists(path, this.data); }
+  getDirectories(path: string): string[] { return }
+  watchDirectory(path: string, callback: ts.DirectoryWatcherCallback, recursive?: boolean): ts.FileWatcher { return new MockFileWatcher(); }
+  watchFile(path: string, callback: ts.FileWatcherCallback): ts.FileWatcher { return new MockFileWatcher(); }
+  readDirectory(path: string, extensions?: string[], exclude?: string[], include?: string[]): string[] { return []; }
+  useCaseSensitiveFileNames: false;
+  setTimeout(callback: (...args: any[]) => void, ms: number, ...args: any[]): any { return undefined; }
+  clearTimeout(timeoutId: any): void { }
+}
+
+export class MockLogger implements Logger {
+  close(): void {}
+  isVerbose(): boolean { return false; }
+  info(s: string): void { }
+  startGroup(): void {}
+  endGroup(): void {}
+  msg(s: string, type?: string): void {}
+}
+
+export class MockFileWatcher {
+  close() {}
+}

server/tsconfig-build.json

@@ -0,0 +1,14 @@
+{
+	"compilerOptions": {
+		"target": "ES5",
+		"module": "commonjs",
+		"moduleResolution": "node",
+		"sourceMap": true,
+		"outDir": "../client/server",
+		"lib": ["es5", "es2015.core", "es2015.promise", "es2015.collection", "es2015.iterable", "dom"],
+		"types": []
+	},
+	"exclude": [
+		"node_modules", "tests"
+	]
+}

server/tsconfig.json

@@ -4,7 +4,7 @@
 		"module": "commonjs",
 		"moduleResolution": "node",
 		"sourceMap": true,
-		"outDir": "../client/server",
+		"outDir": "dist",
 		"lib": ["es5", "es2015.core", "es2015.promise", "es2015.collection", "es2015.iterable", "dom"],
 		"types": []
 	},