When module is none, generate bare files source code.

Move unit tests to Jasmine.

Urigo/angular2-meteor#102

Author: barbatus

compiler-tests.js

@@ -29,9 +29,15 @@ Package.onUse(function(api) {
 });
 
 Package.onTest(function(api) {
-  api.use(['tinytest', 'underscore']);
-  api.use('ecmascript');
+  api.use([
+    'tinytest',
+    'ecmascript',
+    'underscore',
+    'sanjo:[email protected]']);
   api.use('barbatus:typescript-compiler');
 
-  api.addFiles('compiler-tests.js', 'server');
+  api.addFiles([
+    'tests/server/unit/input-file.js',
+    'tests/server/unit/compiler-tests_spec.js'
+  ], 'server');
 });

package.js

@@ -0,0 +1,2 @@
+#!/bin/sh
+VELOCITY_TEST_PACKAGES=1 meteor test-packages --driver-package=velocity:html-reporter ./

run_tests.sh

@@ -0,0 +1,80 @@
+describe('typescript-compiler', () => {
+  let testCodeLine = 'export const foo = "foo"';
+
+  describe('testing options', () => {
+    it('should have commonjs by default', () => {
+      let compiler = new TypeScriptCompiler();
+
+      let inputFile = new InputFile(testCodeLine, 'foo1.ts');
+      compiler.processFilesForTarget([inputFile]);
+
+      expect(inputFile.result).not.toBeNull();
+      expect(inputFile.result.data).toContain('exports.foo');
+    });
+
+    it('should apply extra compiler options', () => {
+      let compiler = new TypeScriptCompiler({
+        module: 'system'
+      });
+
+      let inputFile = new InputFile(testCodeLine, 'foo2.ts');
+      compiler.processFilesForTarget([inputFile]);
+
+      expect(inputFile.result.data).toContain('System.register(\"foo2\"');
+    });
+  });
+
+  describe('testing tsconfig.json', () => {
+    it('config should be recognized and watched', () => {
+      let compiler = new TypeScriptCompiler();
+
+      let configFile = new ConfigFile({
+        compilerOptions: {
+          module: 'system'
+        }
+      });
+      let inputFile = new InputFile(testCodeLine, 'foo3.ts');
+      compiler.processFilesForTarget([inputFile, configFile]);
+
+      expect(inputFile.result.data).toContain('System.register(\"foo3\"');
+
+      // Change config and test.
+      configFile.compilerOptions.module = 'commonjs';
+      compiler.processFilesForTarget([inputFile, configFile]);
+      expect(inputFile.result.data).toContain('exports.foo');
+    });
+  });
+
+  describe('testing diagnostics', () => {
+    it('should log out diagnostics by default', () => {
+      let logger = jasmine.createSpy();
+      let compiler = new TypeScriptCompiler(null, null, logger);
+
+      let configFile = new ConfigFile({
+        compilerOptions: {
+          module: 'system'
+        }
+      });
+      let wrongImport = 'import {api} from "lib";';
+      let inputFile = new InputFile(wrongImport, 'foo4.ts');
+      compiler.processFilesForTarget([inputFile, configFile]);
+
+      expect(logger).toHaveBeenCalled();
+      expect(logger.calls.first().args[0]).toBeDefined();
+    });
+  });
+
+  describe('testing modules', () => {
+    it('should render bare source code if module is none', () => {
+      let compiler = new TypeScriptCompiler({
+        module: 'none'
+      });
+      let moduleFoo = 'module foo {}';
+      let inputFile = new InputFile(moduleFoo, 'foo5.ts');
+      let compiler = new TypeScriptCompiler();
+      compiler.processFilesForTarget([inputFile, configFile]);
+
+      expect(inputFile.result.bare).toBe(true);
+    });
+  });
+});

tests/server/unit/compiler-tests_spec.js

@@ -0,0 +1,56 @@
+const crypto = Npm.require('crypto');
+
+function sha1(content) {
+  let hash = crypto.createHash('sha1');
+  hash.update(content);
+  return hash.digest('hex');
+}
+
+InputFile = class InputFile {
+  constructor(source, fileName, options) {
+    this.source = source;
+    this.fileName = fileName;
+    this.options = options || {};
+  }
+
+  getContentsAsString() {
+    return this.source;
+  }
+
+  getPackageName() {
+    return null;
+  }
+
+  getPathInPackage() {
+    return this.fileName;
+  }
+
+  getBasename() {
+    return this.fileName;
+  }
+
+  getFileOptions() {
+    return this.options;
+  }
+
+  getSourceHash() {
+    return sha1(this.getContentsAsString());
+  }
+
+  addJavaScript(result) {
+    this.result = result;
+  }
+}
+
+ConfigFile = class ConfigFile extends InputFile {
+  constructor(config) {
+    super(JSON.stringify(config), 'tsconfig.json');
+    for (let key in config) {
+      this[key] = config[key];
+    }
+  }
+
+  getContentsAsString() {
+    return JSON.stringify(this);
+  }
+}

tests/server/unit/input-file.js

@@ -37,40 +37,37 @@ TypeScriptCompiler = class TypeScriptCompiler {
 
     const future = new Future;
     async.eachLimit(tsFiles, this.maxParallelism, (inputFile, cb) => {
+      let compilerOptions = this.tsconfig ?
+        this.tsconfig.compilerOptions : null;
+
+      compilerOptions = TypeScript.getCompilerOptions(
+        compilerOptions, this.extraOptions);
+
       let source = inputFile.getContentsAsString();
-      let packageName = inputFile.getPackageName();
       let inputFilePath = inputFile.getPathInPackage();
       let outputFilePath = removeTsExt(inputFilePath) + '.js';
-      let fileOptions = inputFile.getFileOptions();
       let toBeAdded = {
         sourcePath: inputFilePath,
         path: outputFilePath,
         data: source,
         hash: inputFile.getSourceHash(),
         sourceMap: null,
-        bare: !! fileOptions.bare
+        bare: this.isBareFile(inputFile, compilerOptions)
+      };
+
+      let filePath = this.getExtendedPath(inputFile);
+      let typings = this.tsconfig ? this.tsconfig.typings : [];
+      let moduleName = this.getFileModuleName(inputFile, compilerOptions);
+      let tsOptions = {
+        compilerOptions,
+        moduleName,
+        filePath,
+        typings
       };
 
       let error = null;
       try {
-        let compilerOptions = this.tsconfig ?
-          this.tsconfig.compilerOptions : null;
-
-        compilerOptions = TypeScript.getCompilerOptions(
-          compilerOptions, this.extraOptions);
-
-        let filePath = this.getExtendedPath(inputFile);
-        let typings = this.tsconfig ? this.tsconfig.typings : [];
-        let moduleName = this.getFileModuleName(inputFile, compilerOptions);
-
-        let options = {
-          compilerOptions,
-          moduleName,
-          filePath,
-          typings
-        };
-
-        let result = TypeScript.compile(getFileContent, options);
+        let result = TypeScript.compile(getFileContent, tsOptions);
         this.processDiagnostics(inputFile,
           result.diagnostics, compilerOptions);
 
@@ -126,6 +123,13 @@ TypeScriptCompiler = class TypeScriptCompiler {
     return noExt ? removeTsExt(filePath) : filePath;
   }
 
+  isBareFile(inputFile, compilerOptions) {
+    let fileOptions = inputFile.getFileOptions();
+    let packageName = inputFile.getPackageName();
+    return (fileOptions.bare ||
+      (! packageName && compilerOptions.module === 'none'));
+  }
+
   getFileModuleName(inputFile, options) {
     return options.module !== 'none' ?
       this.getExtendedPath(inputFile, true): null;