Convert unit tests to TypeScript (#437)

Author: nicknisi

examples/basic/src/generics.ts

@@ -5,7 +5,7 @@
  * @param value  A generic parameter.
  * @returns A generic return value.
  */
-function test<T>(value:T):T {
+function testFunction<T>(value:T):T {
     return value;
 }
 
@@ -77,4 +77,4 @@ interface ABNumber extends AB<number> {}
  */
 function getGenericArray():Array<string> {
     return [''];
-}
+}

gruntfile.js

@@ -34,7 +34,7 @@ module.exports = function(grunt)
                 configuration: 'tslint.json'
             },
             files: {
-                src: [ 'src/**/*.ts' ]
+                src: [ 'src/**/*.ts', '!src/test/converter/**/*.ts' ]
             }
         },
         'string-replace': {
@@ -64,9 +64,20 @@ module.exports = function(grunt)
                 }
             }
         },
+        copy:  {
+            staticTestFiles: {
+                expand: true,
+                cwd: 'src',
+                src: [
+                    'test/converter/**/*',
+                    'test/renderer/**/*'
+                ],
+                dest: 'dist/'
+            }
+        },
         clean: {
-            specsBefore: ['test/renderer/specs'],
-            specsAfter: ['test/renderer/specs/assets']
+            specsBefore: ['src/test/renderer/specs'],
+            specsAfter: ['src/test/renderer/specs/assets']
         },
         watch: {
             source: {
@@ -76,7 +87,7 @@ module.exports = function(grunt)
         },
         mocha_istanbul: {
             coverage: {
-                src: 'test',
+                src: 'dist/test',
                 options: {
                     mask: '*.js',
                     timeout: 4000
@@ -89,20 +100,21 @@ module.exports = function(grunt)
     grunt.loadNpmTasks('grunt-contrib-watch');
     grunt.loadNpmTasks('grunt-string-replace');
     grunt.loadNpmTasks('grunt-contrib-clean');
+    grunt.loadNpmTasks('grunt-contrib-copy');
     grunt.loadNpmTasks('grunt-ts');
     grunt.loadNpmTasks('grunt-tslint');
     grunt.loadNpmTasks('grunt-mocha-istanbul');
 
     grunt.registerTask('default', ['tslint', 'ts:typedoc', 'string-replace:version']);
-    grunt.registerTask('build_and_test', ['default', 'specs', 'mocha_istanbul:coverage']);
+    grunt.registerTask('build_and_test', ['default', 'specs', 'copy', 'mocha_istanbul:coverage']);
     grunt.registerTask('specs', ['clean:specsBefore', 'build-specs', 'clean:specsAfter']);
 
     grunt.registerTask('build-specs', function() {
         var FS = require('fs-extra');
         var Path = require('path');
         var TypeDoc = require('./');
 
-        var base = Path.join(__dirname, 'test', 'converter');
+        var base = Path.join(__dirname, 'src', 'test', 'converter');
         var app = new TypeDoc.Application({
             mode:   'Modules',
             target: 'ES5',
@@ -127,7 +139,7 @@ module.exports = function(grunt)
         });
 
         var src = Path.join(__dirname, 'examples', 'basic', 'src');
-        var out = Path.join(__dirname, 'test', 'renderer', 'specs');
+        var out = Path.join(__dirname, 'src', 'test', 'renderer', 'specs');
 
         FS.removeSync(out);
         app.generateDocs(app.expandInputFiles([src]), out);

package.json

@@ -49,9 +49,11 @@
     "typescript": "2.1.6"
   },
   "devDependencies": {
+    "@types/mocha": "^2.2.39",
     "grunt": "^1.0.1",
     "grunt-cli": "^1.2.0",
     "grunt-contrib-clean": "^1.0.0",
+    "grunt-contrib-copy": "^1.0.0",
     "grunt-contrib-watch": "^1.0.0",
     "grunt-mocha-istanbul": "^5.0.1",
     "grunt-string-replace": "^1.2.0",
@@ -64,11 +66,12 @@
   "files": [
     "bin",
     "dist",
+    "!dist/test",
     "tasks",
     "LICENSE"
   ],
   "scripts": {
-    "test": "mocha -t 4000",
+    "test": "mocha -t 4000 dist/test",
     "build": "grunt build_and_test",
     "prepublish": "npm run build"
   },

src/lib/utils/events.ts

@@ -326,8 +326,11 @@ export class EventDispatcher {
      * Bind an event to a `callback` function. Passing `"all"` will bind
      * the callback to all events fired.
      */
-    on(name: EventMap|string, callback: EventCallback, context?: any, priority?: number) {
-        this.internalOn(name, callback, context, priority);
+    on(eventMap: EventMap, context?: any);
+    on(eventMap: EventMap, callback?: EventCallback, context?: any, priority?: number);
+    on(name: string, callback: EventCallback, context?: any, priority?: number);
+    on(nameOrMap: EventMap|string, callback: EventCallback, context?: any, priority?: number) {
+        this.internalOn(nameOrMap, callback, context, priority);
         return this;
     }
 
@@ -354,7 +357,9 @@ export class EventDispatcher {
      * are passed in using the space-separated syntax, the handler will fire
      * once for each event, not once for a combination of all events.
      */
-    once(name: EventMap|string, callback: EventCallback, context?: any, priority?: number) {
+    once(eventMap: EventMap, context?: any);
+    once(name: string, callback: EventCallback, context?: any, priority?: any);
+    once(name: EventMap|string, callback?: EventCallback, context?: any, priority?: number) {
         // Map the event into a `{event: once}` object.
         const events = eventsApi(onceMap, <EventMap> {}, name, callback, _.bind(this.off, this));
         return this.on(events, void 0, context, priority);
@@ -366,7 +371,10 @@ export class EventDispatcher {
      * callbacks for the event. If `name` is null, removes all bound
      * callbacks for all events.
      */
-    off(name: EventMap|string, callback: EventCallback, context?: any) {
+    off();
+    off(eventMap: EventMap, context?: any);
+    off(name: string, callback?: EventCallback, context?: any);
+    off(name?: EventMap|string, callback?: EventCallback, context?: any) {
         if (!this._events) {
             return this;
         }
@@ -413,7 +421,9 @@ export class EventDispatcher {
     /**
      * Inversion-of-control versions of `once`.
      */
-    listenToOnce(obj: EventDispatcher, name: EventMap|string, callback: EventCallback, priority?: number) {
+    listenToOnce(obj: EventDispatcher, eventMap: EventMap);
+    listenToOnce(obj: EventDispatcher, name: string, callback: EventCallback, priority?: number);
+    listenToOnce(obj: EventDispatcher, name: EventMap|string, callback?: EventCallback, priority?: number) {
         // Map the event into a `{event: once}` object.
         const events = eventsApi(onceMap, <EventMap> {}, name, callback, _.bind(this.stopListening, this, obj));
         return this.listenTo(obj, events, void 0, priority);

test/converter.js renamed to src/test/converter.ts

@@ -1,25 +1,27 @@
-var TypeDoc = require("../");
-var FS      = require('fs');
-var Path    = require('path');
-var Assert  = require("assert");
+import { Application, resetReflectionID, normalizePath, ProjectReflection } from '..';
+import * as FS from 'fs';
+import * as Path from 'path';
+import Assert = require('assert');
 
-
-function compareReflections(fixture, spec, path) {
-    var key;
+function compareReflections(fixture, spec, path?: string) {
     path = (path ? path + '/' : '') + spec.name;
     Assert.deepEqual(fixture, spec);
 
-    for (key in spec) {
-        if (!spec.hasOwnProperty(key)) continue;
+    for (let key in spec) {
+        if (!spec.hasOwnProperty(key)) {
+            continue;
+        }
         Assert(fixture.hasOwnProperty(key), path + ': Missing property "' + key + '"');
     }
 
-    for (key in fixture) {
-        if (!fixture.hasOwnProperty(key) || typeof fixture[key] == 'undefined') continue;
+    for (let key in fixture) {
+        if (!fixture.hasOwnProperty(key) || typeof fixture[key] === 'undefined') {
+            continue;
+        }
         Assert(spec.hasOwnProperty(key), path + ': Unknown property "' + key + '"');
 
-        var a = fixture[key];
-        var b = spec[key];
+        const a = fixture[key];
+        const b = spec[key];
         Assert(a instanceof Object === b instanceof Object, path + ': Property "' + key + '" type mismatch');
 
         if (a instanceof Object) {
@@ -43,26 +45,24 @@ function compareReflections(fixture, spec, path) {
     }
 }
 
-
 function compareChildren(fixture, spec, path) {
-    var a = fixture.map(function(child) { return child.id; });
-    var b = spec.map(function(child) { return child.id; });
+    const a = fixture.map(function(child) { return child.id; });
+    const b = spec.map(function(child) { return child.id; });
 
-    Assert(a.length == b.length, path + ': Number of children differs');
+    Assert(a.length === b.length, path + ': Number of children differs');
     Assert(a.every(function(u, i) { return u === b[i]; }), path + ': Children are different');
 
     fixture.forEach(function(a, index) {
         compareReflections(a, spec[index], path);
     });
 }
 
-
 describe('Converter', function() {
-    var base = Path.join(__dirname, 'converter');
-    var app;
+    const base = Path.join(__dirname, 'converter');
+    let app: Application;
 
     it('constructs', function() {
-        app = new TypeDoc.Application({
+        app = new Application({
             mode:   'Modules',
             logger: 'none',
             target: 'ES5',
@@ -73,22 +73,24 @@ describe('Converter', function() {
     });
 
     FS.readdirSync(base).forEach(function (directory) {
-        var path = Path.join(base, directory);
-        if (!FS.lstatSync(path).isDirectory()) return;
+        const path = Path.join(base, directory);
+        if (!FS.lstatSync(path).isDirectory()) {
+            return;
+        }
 
         describe(directory, function() {
-            var result;
+            let result: ProjectReflection;
 
             it('converts fixtures', function() {
-                TypeDoc.resetReflectionID();
+                resetReflectionID();
                 result = app.convert(app.expandInputFiles([path]));
-                Assert(result instanceof TypeDoc.ProjectReflection, 'No reflection returned');
+                Assert(result instanceof ProjectReflection, 'No reflection returned');
             });
 
             it('matches specs', function() {
-                var specs = JSON.parse(FS.readFileSync(Path.join(path, 'specs.json')));
-                var data = JSON.stringify(result.toObject(), null, '  ');
-                data = data.split(TypeDoc.normalizePath(base)).join('%BASE%');
+                const specs = JSON.parse(FS.readFileSync(Path.join(path, 'specs.json')).toString());
+                let data = JSON.stringify(result.toObject(), null, '  ');
+                data = data.split(normalizePath(base)).join('%BASE%');
 
                 compareReflections(JSON.parse(data), specs);
             });