Resolve issues with unit tests

Author: clbond

source/application/compiler/compiler.ts

@@ -102,7 +102,13 @@ export class Compiler {
 
     const templatedProgram = this.createProgram(parsedCommandLine.fileNames, suboptions, compilerVmHost, program);
 
-    templatedProgram.emit(undefined, writer, null, false);
+    const emitResult = templatedProgram.emit(undefined, writer, null, false);
+    if (emitResult) {
+      this.conditionalException(emitResult.diagnostics);
+    }
+    else {
+      throw new CompilerException('Complete compilation failure for unknown reason');
+    }
   }
 
   private createProgram(files: Array<string>, compilerOptions: CompilerOptions, compilerHost: CompilerHost, previousProgram?: Program): Program {

source/application/compiler/tests/compiler.ts

@@ -1,5 +1,3 @@
-import {NgModuleFactory} from '@angular/core';
-
 import {getApplicationProject} from 'test-fixtures';
 
 import {Compiler} from '../compiler';
@@ -15,7 +13,6 @@ describe('Compiler', () => {
     const module = await compiler.compile();
     expect(module).not.toBeNull();
     expect(typeof module).toBe('object');
-    expect(module instanceof NgModuleFactory).toBe(true);
-    expect((<{name?}>module).name).toBe('BasicInlineApplicationNgFactory');
+    expect(module.constructor.name).toBe('NgModuleFactory');
   });
 });

source/application/compiler/vm/tests/vm.ts

@@ -15,7 +15,7 @@ describe('VirtualMachine', () => {
     vmexec(vm => {
       vm.define('/foo.js', 'foo', 'return 0');
 
-      const result = vm.require('./foo');
+      const result = vm.require('foo');
       expect(result).not.toBeNull();
       expect(result).toBe(0);
     });
@@ -40,7 +40,7 @@ describe('VirtualMachine', () => {
     vmexec(vm => {
       vm.define('/foo.js', 'foo', 'return require("@angular/core")');
 
-      const core = vm.require('./foo');
+      const core = vm.require('foo');
       expect(core).not.toBeNull();
       expect(core.createPlatform).not.toBeNull();
     });

source/application/compiler/vm/vm.ts

@@ -1,4 +1,6 @@
-import {Context, Script, createContext} from 'vm';
+import 'reflect-metadata';
+
+import {Script, createContext} from 'vm';
 
 import {dirname, join, normalize} from 'path';
 
@@ -9,19 +11,15 @@ import {VirtualMachineException} from 'exception';
 import {transpile} from './transpile';
 
 export class VirtualMachine implements Disposable {
-  private scripts = new Map<string, Script>();
+  private scripts = new Map<string, [Script, string]>();
   private modules = new Map<string, any>();
 
   private paths = new Set<string>();
   private files = new Set<string>();
 
   private fileContents = new Map<string, string>();
 
-  private context: Context;
-
-  constructor() {
-    this.context = createContext({global, require: mid => this.require(mid)});
-  }
+  private global = {Reflect};
 
   read(filename): string {
     return this.fileContents.get(filename);
@@ -39,18 +37,9 @@ export class VirtualMachine implements Disposable {
       throw new VirtualMachineException(`Cannot overwrite existing module '${normalizedModuleId}'`);
     }
 
-    const preamble = {exports: {}, filename, id: normalizedModuleId};
-
-    const wrappedCode = `(function() {
-      const module = ${JSON.stringify(preamble)};
-      const exports = module.exports;
-      ${code};
-      return module.exports;
-    })()`;
-
-    const script = new Script(wrappedCode, {filename, displayErrors: true});
+    const script = new Script(code, {filename, displayErrors: true});
 
-    this.scripts.set(moduleId, script);
+    this.scripts.set(moduleId, [script, filename]);
   }
 
   private requireStack = new Array<string>();
@@ -68,17 +57,26 @@ export class VirtualMachine implements Disposable {
       if (script != null) {
         this.requireStack.push(moduleId);
         try {
-          this.modules.set(normalizedModuleId, this.executeScript(script, moduleId));
+          const [executable, filename] = script;
+          moduleResult = this.executeScript(executable, filename, normalizedModuleId);
+
+          this.modules.set(normalizedModuleId, moduleResult);
         }
         finally {
           this.requireStack.pop();
         }
       }
       else {
         moduleResult = this.conditionalTranspile(normalizedModuleId);
+
         this.modules.set(moduleId, moduleResult);
       }
     }
+
+    if (moduleResult == null) {
+      throw new VirtualMachineException(`Require of ${moduleId} (normalized: ${normalizedModuleId}) returned null`);
+    }
+
     return moduleResult;
   }
 
@@ -99,13 +97,26 @@ export class VirtualMachine implements Disposable {
     this.modules.clear();
   }
 
-  private executeScript(script: Script, moduleId: string) {
+  private executeScript(script: Script, filename: string, moduleId: string) {
     try {
-      return script.runInContext(this.context);
+      const exports = {};
+
+      const context = createContext({
+        require: mid => this.require(mid),
+        exports,
+        global: this.global,
+        module: {exports, filename, id: moduleId},
+        __filename: filename,
+        __dirname: dirname(filename),
+      });
+
+      script.runInContext(context);
+
+      return exports;
     }
     catch (exception) {
       throw new VirtualMachineException(
-        `Exception in ${moduleId} in sandboxed virtual machine: ${exception.stack}`, exception);
+        `Exception in ${moduleId} in sandboxed virtual machine: ${exception.toString()}`, exception);
     }
   }
 
@@ -114,26 +125,23 @@ export class VirtualMachine implements Disposable {
   }
 
   normalizeModuleId(to: string): string {
-    const stack = this.requireStack;
-
     if (/^\./.test(to)) {
-      if (this.requireStack.length > 0) {
+      const stack = this.requireStack;
+      if (stack.length > 0) {
         return join(dirname(stack[stack.length - 1]), to);
       }
-      else {
-        throw new VirtualMachineException(
-          `Cannot determine relative path to ${to} (require stack: ${stack.join(' -> ')})`);
-      }
     }
+
     return to;
   }
 
   private conditionalTranspile(moduleId: string) {
-    if (/^\@angular/.test(moduleId)) {
+    if (/^@angular/.test(moduleId)) {
       const [path, code] = transpile(moduleId);
       this.define(path, moduleId, code);
       return this.require(moduleId);
     }
+
     return require(moduleId);
   }
 }

source/exception.ts

@@ -3,7 +3,7 @@ export class Exception extends Error {
 
   constructor(msg: string, innerException?: Error) {
     if (innerException) {
-      super(`${msg} -> ${innerException.stack}`);
+      super(`${msg} -> ${innerException.toString()}`);
     }
     else {
       super(msg);