path: root/js/compiler_test.ts

// Copyright 2018 the Deno authors. All rights reserved. MIT license.
import { test, assert, assertEqual } from "./testing/testing.ts";
import * as compiler from "compiler";
import * as ts from "typescript";

// We use a silly amount of `any` in these tests...
// tslint:disable:no-any

const { DenoCompiler, ModuleMetaData } = compiler;

// Enums like this don't exist at runtime, so local copy
enum ScriptKind {
  JS = 1,
  TS = 3,
  JSON = 6
}

interface ModuleInfo {
  moduleName: string | null;
  filename: string | null;
  sourceCode: string | null;
  outputCode: string | null;
}

const compilerInstance = DenoCompiler.instance();

// References to orignal items we are going to mock
const originals = {
  _globalEval: (compilerInstance as any)._globalEval,
  _log: (compilerInstance as any)._log,
  _os: (compilerInstance as any)._os,
  _ts: (compilerInstance as any)._ts,
  _service: (compilerInstance as any)._service,
  _window: (compilerInstance as any)._window
};

function mockModuleInfo(
  moduleName: string | null,
  filename: string | null,
  sourceCode: string | null,
  outputCode: string | null
): ModuleInfo {
  return {
    moduleName,
    filename,
    sourceCode,
    outputCode
  };
}

// Some fixtures we will us in testing
const fooBarTsSource = `import * as compiler from "compiler";
console.log(compiler);
export const foo = "bar";
`;

const fooBazTsSource = `import { foo } from "./bar.ts";
console.log(foo);
`;

// TODO(#23) Remove source map strings from fooBarTsOutput.
// tslint:disable:max-line-length
const fooBarTsOutput = `define(["require", "exports", "compiler"], function (require, exports, compiler) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    console.log(compiler);
    exports.foo = "bar";
});
//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiZmlsZTovLy9yb290L3Byb2plY3QvZm9vL2Jhci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7SUFDQSxPQUFPLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxDQUFDO0lBQ1QsUUFBQSxHQUFHLEdBQUcsS0FBSyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0ICogYXMgY29tcGlsZXIgZnJvbSBcImNvbXBpbGVyXCI7XG5jb25zb2xlLmxvZyhjb21waWxlcik7XG5leHBvcnQgY29uc3QgZm9vID0gXCJiYXJcIjtcbiJdfQ==
//# sourceURL=/root/project/foo/bar.ts`;

// TODO(#23) Remove source map strings from fooBazTsOutput.
const fooBazTsOutput = `define(["require", "exports", "./bar.ts"], function (require, exports, bar_ts_1) {
  "use strict";
  Object.defineProperty(exports, "__esModule", { value: true });
  console.log(bar_ts_1.foo);
});
//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmF6LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiZmlsZTovLy9yb290L3Byb2plY3QvZm9vL2Jhei50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7SUFDQSxPQUFPLENBQUMsR0FBRyxDQUFDLFlBQUcsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgZm9vIH0gZnJvbSBcIi4vYmFyLnRzXCI7XG5jb25zb2xlLmxvZyhmb28pO1xuIl19
//# sourceURL=/root/project/foo/baz.ts`;
// tslint:enable:max-line-length

const moduleMap: {
  [containFile: string]: { [moduleSpecifier: string]: ModuleInfo };
} = {
  "/root/project": {
    "foo/bar.ts": mockModuleInfo(
      "foo/bar",
      "/root/project/foo/bar.ts",
      fooBarTsSource,
      null
    ),
    "foo/baz.ts": mockModuleInfo(
      "foo/baz",
      "/root/project/foo/baz.ts",
      fooBazTsSource,
      null
    ),
    "foo/qat.ts": mockModuleInfo(
      "foo/qat",
      "/root/project/foo/qat.ts",
      null,
      null
    )
  },
  "/root/project/foo/baz.ts": {
    "./bar.ts": mockModuleInfo(
      "foo/bar",
      "/root/project/foo/bar.ts",
      fooBarTsSource,
      fooBarTsOutput
    ),
    "./qat.ts": mockModuleInfo(
      "foo/qat",
      "/root/project/foo/qat.ts",
      "export const foo = 'bar'",
      null
    )
  }
};

const emittedFiles = {
  "/root/project/foo/qat.ts": "console.log('foo');"
};

let globalEvalStack: string[] = [];
let getEmitOutputStack: string[] = [];
let logStack: any[][] = [];
let codeCacheStack: Array<{
  fileName: string;
  sourceCode: string;
  outputCode: string;
}> = [];
let codeFetchStack: Array<{
  moduleSpecifier: string;
  containingFile: string;
}> = [];

function reset() {
  codeFetchStack = [];
  codeCacheStack = [];
  logStack = [];
  getEmitOutputStack = [];
  globalEvalStack = [];
}

let mockDeps: string[] | undefined;
let mockFactory: compiler.AmdFactory;

function globalEvalMock(x: string): void {
  globalEvalStack.push(x);
  if (windowMock.define && mockDeps && mockFactory) {
    windowMock.define(mockDeps, mockFactory);
  }
}
function logMock(...args: any[]): void {
  logStack.push(args);
}
const osMock: compiler.Os = {
  codeCache(fileName: string, sourceCode: string, outputCode: string): void {
    codeCacheStack.push({ fileName, sourceCode, outputCode });
  },
  codeFetch(moduleSpecifier: string, containingFile: string): ModuleInfo {
    codeFetchStack.push({ moduleSpecifier, containingFile });
    if (containingFile in moduleMap) {
      if (moduleSpecifier in moduleMap[containingFile]) {
        return moduleMap[containingFile][moduleSpecifier];
      }
    }
    return mockModuleInfo(null, null, null, null);
  },
  exit(code: number): never {
    throw new Error(`os.exit(${code})`);
  }
};
const tsMock: compiler.Ts = {
  createLanguageService(host: ts.LanguageServiceHost): ts.LanguageService {
    return {} as ts.LanguageService;
  },
  formatDiagnosticsWithColorAndContext(
    diagnostics: ReadonlyArray<ts.Diagnostic>,
    host: ts.FormatDiagnosticsHost
  ): string {
    return "";
  }
};

const getEmitOutputPassThrough = true;

const serviceMock = {
  getCompilerOptionsDiagnostics(): ts.Diagnostic[] {
    return originals._service.getCompilerOptionsDiagnostics.call(
      originals._service
    );
  },
  getEmitOutput(fileName: string): ts.EmitOutput {
    getEmitOutputStack.push(fileName);
    if (getEmitOutputPassThrough) {
      return originals._service.getEmitOutput.call(
        originals._service,
        fileName
      );
    }
    if (fileName in emittedFiles) {
      return {
        outputFiles: [{ text: emittedFiles[fileName] }] as any,
        emitSkipped: false
      };
    }
    return { outputFiles: [], emitSkipped: false };
  },
  getSemanticDiagnostics(fileName: string): ts.Diagnostic[] {
    return originals._service.getSemanticDiagnostics.call(
      originals._service,
      fileName
    );
  },
  getSyntacticDiagnostics(fileName: string): ts.Diagnostic[] {
    return originals._service.getSyntacticDiagnostics.call(
      originals._service,
      fileName
    );
  }
};
const windowMock: { define?: compiler.AmdDefine } = {};
const mocks = {
  _globalEval: globalEvalMock,
  _log: logMock,
  _os: osMock,
  _ts: tsMock,
  _service: serviceMock,
  _window: windowMock
};

// Setup the mocks
test(function compilerTestsSetup() {
  assert("_globalEval" in compilerInstance);
  assert("_log" in compilerInstance);
  assert("_os" in compilerInstance);
  assert("_ts" in compilerInstance);
  assert("_service" in compilerInstance);
  assert("_window" in compilerInstance);
  Object.assign(compilerInstance, mocks);
});

test(function compilerInstance() {
  assert(DenoCompiler != null);
  assert(DenoCompiler.instance() != null);
});

// Testing the internal APIs

test(function compilerMakeDefine() {
  const moduleMetaData = new ModuleMetaData(
    "/root/project/foo/bar.ts",
    fooBarTsSource,
    fooBarTsOutput
  );
  const localDefine = compilerInstance.makeDefine(moduleMetaData);
  let factoryCalled = false;
  localDefine(
    ["require", "exports", "compiler"],
    (_require, _exports, _compiler): void => {
      factoryCalled = true;
      assertEqual(
        typeof _require,
        "function",
        "localRequire should be a function"
      );
      assert(_exports != null);
      assert(
        Object.keys(_exports).length === 0,
        "exports should have no properties"
      );
      assert(compiler === _compiler, "compiler should be passed to factory");
    }
  );
  assert(factoryCalled, "Factory expected to be called");
});

// TODO testMakeDefineExternalModule - testing that make define properly runs
// external modules, this is implicitly tested though in
// `compilerRunMultiModule`

test(function compilerLocalRequire() {
  const moduleMetaData = new ModuleMetaData(
    "/root/project/foo/baz.ts",
    fooBazTsSource,
    fooBazTsOutput
  );
  const localDefine = compilerInstance.makeDefine(moduleMetaData);
  let requireCallbackCalled = false;
  localDefine(
    ["require", "exports"],
    (_require, _exports, _compiler): void => {
      assertEqual(typeof _require, "function");
      _require(
        ["./qat.ts"],
        _qat => {
          requireCallbackCalled = true;
          assert(_qat);
        },
        () => {
          throw new Error("Should not error");
        }
      );
    }
  );
  assert(requireCallbackCalled, "Factory expected to be called");
});

test(function compilerRun() {
  // equal to `deno foo/bar.ts`
  reset();
  const result = compilerInstance.run("foo/bar.ts", "/root/project");
  assert(result instanceof ModuleMetaData);
  assertEqual(codeFetchStack.length, 1);
  assertEqual(codeCacheStack.length, 1);
  assertEqual(globalEvalStack.length, 1);

  const lastGlobalEval = globalEvalStack.pop();
  assertEqual(lastGlobalEval, fooBarTsOutput);
  const lastCodeFetch = codeFetchStack.pop();
  assertEqual(lastCodeFetch, {
    moduleSpecifier: "foo/bar.ts",
    containingFile: "/root/project"
  });
  const lastCodeCache = codeCacheStack.pop();
  assertEqual(lastCodeCache, {
    fileName: "/root/project/foo/bar.ts",
    sourceCode: fooBarTsSource,
    outputCode: fooBarTsOutput
  });
});

test(function compilerRunMultiModule() {
  // equal to `deno foo/baz.ts`
  reset();
  let factoryRun = false;
  mockDeps = ["require", "exports", "compiler"];
  mockFactory = (...deps: any[]) => {
    const [_require, _exports, _compiler] = deps;
    assertEqual(typeof _require, "function");
    assertEqual(typeof _exports, "object");
    assertEqual(_compiler, compiler);
    factoryRun = true;
    Object.defineProperty(_exports, "__esModule", { value: true });
    _exports.foo = "bar";
    // it is too complicated to test the outer factory, because the localised
    // make define already has a reference to this factory and it can't really
    // be easily unwound.  So we will do what we can with the inner one and
    // then just clear it...
    mockDeps = undefined;
    mockFactory = undefined;
  };

  const result = compilerInstance.run("foo/baz.ts", "/root/project");
  assert(result instanceof ModuleMetaData);
  // we have mocked that foo/bar.ts is already cached, so two fetches,
  // but only a single cache
  assertEqual(codeFetchStack.length, 2);
  assertEqual(codeCacheStack.length, 1);
  // because of the challenges with the way the module factories are generated
  // we only get one invocation of the `globalEval` mock.
  assertEqual(globalEvalStack.length, 1);
  assert(factoryRun);
});

// TypeScript LanguageServiceHost APIs

test(function compilerGetCompilationSettings() {
  const result = compilerInstance.getCompilationSettings();
  for (const key of [
    "allowJs",
    "module",
    "outDir",
    "inlineSourceMap",
    "inlineSources",
    "stripComments",
    "target"
  ]) {
    assert(key in result, `Expected "${key}" in compiler options.`);
  }
});

test(function compilerGetNewLine() {
  const result = compilerInstance.getNewLine();
  assertEqual(result, "\n", "Expected newline value of '\\n'.");
});

test(function compilerGetScriptFileNames() {
  compilerInstance.run("foo/bar.ts", "/root/project");
  const result = compilerInstance.getScriptFileNames();
  assertEqual(result.length, 1, "Expected only a single filename.");
  assertEqual(result[0], "/root/project/foo/bar.ts");
});

test(function compilerGetScriptKind() {
  assertEqual(compilerInstance.getScriptKind("foo.ts"), ScriptKind.TS);
  assertEqual(compilerInstance.getScriptKind("foo.d.ts"), ScriptKind.TS);
  assertEqual(compilerInstance.getScriptKind("foo.js"), ScriptKind.JS);
  assertEqual(compilerInstance.getScriptKind("foo.json"), ScriptKind.JSON);
  assertEqual(compilerInstance.getScriptKind("foo.txt"), ScriptKind.JS);
});

test(function compilerGetScriptVersion() {
  const moduleMetaData = compilerInstance.resolveModule(
    "foo/bar.ts",
    "/root/project"
  );
  assertEqual(
    compilerInstance.getScriptVersion(moduleMetaData.fileName),
    "1",
    "Expected known module to have script version of 1"
  );
});

test(function compilerGetScriptVersionUnknown() {
  assertEqual(
    compilerInstance.getScriptVersion("/root/project/unknown_module.ts"),
    "",
    "Expected unknown module to have an empty script version"
  );
});

test(function compilerGetScriptSnapshot() {
  const moduleMetaData = compilerInstance.resolveModule(
    "foo/bar.ts",
    "/root/project"
  );
  const result = compilerInstance.getScriptSnapshot(moduleMetaData.fileName);
  assert(result != null, "Expected snapshot to be defined.");
  assertEqual(result.getLength(), fooBarTsSource.length);
  assertEqual(
    result.getText(0, 6),
    "import",
    "Expected .getText() to equal 'import'"
  );
  assertEqual(result.getChangeRange(result), undefined);
  assert(!("dispose" in result));
});

test(function compilerGetCurrentDirectory() {
  assertEqual(compilerInstance.getCurrentDirectory(), "");
});

test(function compilerGetDefaultLibFileName() {
  assertEqual(
    compilerInstance.getDefaultLibFileName(),
    "$asset$/lib.globals.d.ts"
  );
});

test(function compilerUseCaseSensitiveFileNames() {
  assertEqual(compilerInstance.useCaseSensitiveFileNames(), true);
});

test(function compilerReadFile() {
  let doesThrow = false;
  try {
    compilerInstance.readFile("foobar.ts");
  } catch (e) {
    doesThrow = true;
    assert(e.message.includes("Not implemented") === true);
  }
  assert(doesThrow);
});

test(function compilerFileExists() {
  const moduleMetaData = compilerInstance.resolveModule(
    "foo/bar.ts",
    "/root/project"
  );
  assert(compilerInstance.fileExists(moduleMetaData.fileName));
  assert(compilerInstance.fileExists("$asset$/compiler.d.ts"));
  assertEqual(
    compilerInstance.fileExists("/root/project/unknown-module.ts"),
    false
  );
});

test(function compilerResolveModuleNames() {
  const results = compilerInstance.resolveModuleNames(
    ["foo/bar.ts", "foo/baz.ts", "$asset$/lib.globals.d.ts", "deno"],
    "/root/project"
  );
  assertEqual(results.length, 4);
  const fixtures: Array<[string, boolean]> = [
    ["/root/project/foo/bar.ts", false],
    ["/root/project/foo/baz.ts", false],
    ["$asset$/lib.globals.d.ts", true],
    ["$asset$/deno.d.ts", true]
  ];
  for (let i = 0; i < results.length; i++) {
    const result = results[i];
    const [resolvedFileName, isExternalLibraryImport] = fixtures[i];
    assertEqual(result.resolvedFileName, resolvedFileName);
    assertEqual(result.isExternalLibraryImport, isExternalLibraryImport);
  }
});

// Remove the mocks
test(function compilerTestsTeardown() {
  Object.assign(compilerInstance, originals);
});