feat: cache key + tests

.npmignore

@@ -1,6 +1,5 @@
 # Tests
 e2e
-test
 
 # Developement scripts
 scripts 

e2e/jest.config.js

@@ -1,10 +1,9 @@
+const base = require('../jest.config');
+
 module.exports = {
-  transform: {
-    '\\.ts$': '<rootDir>/../dist/index.js',
-  },
-  testRegex: '/__tests__/.+\\.test\\.ts$',
-  collectCoverageFrom: ['<rootDir>/../src/**/*.ts'],
-  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json'],
-  testEnvironment: 'node',
+  ...base,
+  rootDir: '.',
+  testRegex: '/__tests__/.+\\.(test|spec)\\.ts$',
+  coverageDirectory: '<rootDir>/../coverage/e2e',
   snapshotSerializers: ['<rootDir>/__serializers__/test-run-result.ts'],
 };

jest.config.js

@@ -1,10 +1,16 @@
 module.exports = {
-  rootDir: './test',
+  rootDir: 'src',
   transform: {
     '\\.ts$': '<rootDir>/../dist/index.js',
   },
-  testRegex: '/.+\\.spec\\.ts$',
-  collectCoverageFrom: ['<rootDir>/../src/**/*.ts'],
+  testRegex: '\\.(spec|test)\\.ts$',
+  coverageDirectory: '<rootDir>/../coverage/unit',
+  collectCoverageFrom: [
+    '<rootDir>/../src/**/*.ts',
+    '!<rootDir>/../src/**/*.spec.ts',
+    '!<rootDir>/../src/**/*.test.ts',
+    '!<rootDir>/../src/**/__*__/',
+  ],
   moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json'],
   testEnvironment: 'node',
 };

package.json

@@ -47,6 +47,7 @@
   "devDependencies": {
     "@types/babel__core": "^7.0.1",
     "@types/fs-extra": "5.0.4",
+    "@types/gist-package-json": "git+https://gist.github.com/5c1cc527fe6b5b7dba41fec7fe54bf6e.git",
     "@types/jest": "^23.3.1",
     "@types/node": "^10.5.7",
     "closest-file-data": "^0.1.4",

test/__helpers__/sources-mock.ts → src/__helpers__/fakers.ts

@@ -1,10 +1,15 @@
-import { resolve } from 'path';
+import { TsJestGlobalOptions } from '../types';
+import { resolve, relative } from 'path';
+import spyThese from './spy-these';
+import realFs from 'fs';
 
-export function filePathMock(relPath: string): string {
+export function filePath(relPath: string): string {
   return resolve(__dirname, '..', '..', relPath);
 }
 
-export function transpiledTsSourceMock() {
+export const rootDir = filePath('');
+
+export function transpiledTsSource() {
   return `
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
@@ -23,7 +28,7 @@ describe('hello', function () {
 `;
 }
 
-export function tsSourceMock() {
+export function typescriptSource() {
   return `
 import upper from './upper';
 import lower from './lower';
@@ -39,3 +44,24 @@ describe('hello', () => {
 });
 `;
 }
+
+export function tsJestConfig<T extends TsJestGlobalOptions>(
+  options?: TsJestGlobalOptions,
+): T {
+  return { ...options } as any;
+}
+
+export function jestConfig<T extends jest.ProjectConfig>(
+  options?: jest.InitialOptions,
+  tsJestOptions?: TsJestGlobalOptions,
+): T {
+  const res = {
+    globals: {},
+    moduleFileExtensions: ['ts', 'js'],
+    ...options,
+  } as any;
+  if (tsJestOptions) {
+    res.globals['ts-jest'] = tsJestConfig(tsJestOptions);
+  }
+  return res;
+}

src/__helpers__/spy-these.ts

@@ -0,0 +1,29 @@
+export default function spyThese<T extends object, K extends keyof T>(
+  object: T,
+  implementations: { [key in K]: T[K] | any | undefined },
+): { [key in K]: jest.SpyInstance<T[K]> } & { mockRestore: () => void } {
+  const keys = Object.keys(implementations) as K[];
+  const res = keys.reduce(
+    (map, key) => {
+      const actual = object[key] as any;
+      const spy = jest.spyOn(object, key as K);
+      if (implementations[key]) {
+        const impl = implementations[key] as (...args: any[]) => any;
+        if (impl.length && /\W\$super\W/.test(impl.toString())) {
+          spy.mockImplementation(function(this: T, ...args: any[]) {
+            return impl.call(this, () => actual.apply(this, args), ...args);
+          });
+        } else {
+          spy.mockImplementation(impl);
+        }
+      }
+      return map;
+    },
+    {} as any,
+  );
+  // utility to restore all
+  res.mockRestore = () => {
+    keys.forEach(key => res[key].mockRestore());
+  };
+  return res;
+}

src/__mocks__/ts-program.ts

@@ -0,0 +1,21 @@
+import * as fakers from '../__helpers__/fakers';
+import { TsJestConfig, TsJestProgram } from '../types';
+import { ParsedCommandLine } from 'typescript';
+
+// tslint:disable-next-line:variable-name
+export let __tsConfig: any = {};
+
+export default class TsProgramMock implements TsJestProgram {
+  get parsedConfig(): ParsedCommandLine {
+    return __tsConfig;
+  }
+
+  constructor(
+    public rootDir: string = fakers.filePath(''),
+    public tsJestConfig: TsJestConfig = fakers.tsJestConfig(),
+  ) {}
+
+  transpileModule(_: string, source: string) {
+    return source;
+  }
+}

test/__snapshots__/ts-jest-transformer.spec.ts.snap → src/__snapshots__/ts-jest-transformer.spec.ts.snap

@@ -1,6 +1,6 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
-exports[`hoisting should hoist jest.mock calls using babel 1`] = `
+exports[`process hoisting should hoist jest.mock calls using babel 1`] = `
 "
 \\"use strict\\";
 

src/ts-jest-transformer.spec.ts

@@ -0,0 +1,92 @@
+import TsJestTransformer from './ts-jest-transformer';
+import * as fakers from './__helpers__/fakers';
+import * as babelCfg from './utils/babel-config';
+import * as closesPkgJson from './utils/closest-package-json';
+import * as TsJestProgram from './ts-program';
+
+jest.mock('./ts-program');
+jest.mock('./utils/closest-package-json');
+jest.mock('./utils/backports');
+
+const mocks = {
+  babelConfig: undefined as any,
+  set packageJson(val: any) {
+    (closesPkgJson as any).__default = val;
+  },
+  set tsConfig(val: any) {
+    (TsJestProgram as any).__tsConfig = val;
+  },
+  reset() {
+    this.babelConfig = undefined;
+    this.packageJson = { name: 'mock' };
+    this.tsConfig = {};
+  },
+};
+beforeAll(() => {
+  jest
+    .spyOn(babelCfg, 'loadDefault')
+    .mockImplementation(() => mocks.babelConfig);
+});
+afterEach(() => {
+  mocks.reset();
+});
+
+describe('process', () => {
+  describe('hoisting', () => {
+    const transformer = new TsJestTransformer();
+    it('should hoist jest.mock calls using babel', () => {
+      const config = fakers.jestConfig({}, { babelJest: true });
+      const result = transformer.process(
+        fakers.transpiledTsSource(),
+        fakers.filePath('path/to/file.ts'),
+        config,
+      ) as jest.TransformedSource;
+      expect(result.code).toMatchSnapshot();
+    });
+  }); // hoisting
+}); // process
+
+describe('getCacheKey', () => {
+  const fakeSource = fakers.typescriptSource();
+  const fakeFilePath = fakers.filePath('file.ts');
+  const fakeJestConfig = JSON.stringify(
+    fakers.jestConfig({}, { babelJest: true }),
+  );
+
+  const call: typeof TsJestTransformer['prototype']['getCacheKey'] = (
+    // tslint:disable-next-line:trailing-comma
+    ...args
+  ) => new TsJestTransformer().getCacheKey(...args);
+  const defaultCall = () => call(fakeSource, fakeFilePath, fakeJestConfig);
+
+  it('should be a 28 chars string, different for each case', () => {
+    const allCacheKeys = [
+      defaultCall(),
+      call('const b = 2', fakeFilePath, fakeJestConfig),
+      call(fakeSource, fakers.filePath('other-file.ts'), fakeJestConfig),
+      call(fakeSource, fakeFilePath, '{"rootDir": "./sub"}'),
+      call(fakeSource, fakeFilePath, fakeJestConfig, { instrument: true }),
+      call(fakeSource, fakeFilePath, fakeJestConfig, { rootDir: '/child' }),
+    ];
+
+    mocks.babelConfig = '{sourceMaps: true}';
+    allCacheKeys.push(defaultCall());
+    mocks.reset();
+
+    mocks.tsConfig = '{"files": []}';
+    allCacheKeys.push(defaultCall());
+    mocks.reset();
+
+    mocks.packageJson = '{"name": "dummy"}';
+    allCacheKeys.push(defaultCall());
+    mocks.reset();
+
+    // uniq array should equal original
+    expect(
+      allCacheKeys.filter((k, i) => allCacheKeys.indexOf(k) === i),
+    ).toEqual(allCacheKeys);
+    allCacheKeys.forEach(cacheKey => {
+      expect(cacheKey).toHaveLength(28);
+    });
+  }); // all different and 28 chars
+}); // getCacheKey

src/ts-jest-transformer.ts

@@ -7,16 +7,23 @@ import jestRootDir from './utils/jest-root-dir';
 import { sep, resolve } from 'path';
 import parseJsonUnsafe from './utils/parse-json-unsafe';
 import * as babelCfg from './utils/babel-config';
-
-// TODO: could be used if we need to handle the cache key ourself
-// const normalizeJestConfig = (jestConfig: jest.ProjectConfig): jest.ProjectConfig => {
-//   const config = { ...jestConfig, rootDir: rootDirFor(jestConfig) };
-//   delete config.cacheDirectory;
-//   delete config.name;
-//   return config;
-// };
+import closestPatckageJson from './utils/closest-package-json';
+import sha1 from './utils/sha1';
 
 export default class TsJestTransformer implements jest.Transformer {
+  @Memoize(jestRootDir)
+  sanitizedJestConfigFor<T extends jest.ProjectConfig | jest.InitialOptions>(
+    jestConfig: T,
+  ): T {
+    const config = {
+      ...(jestConfig as object),
+      rootDir: jestRootDir(jestConfig),
+    } as T;
+    delete config.cacheDirectory;
+    delete config.name;
+    return config;
+  }
+
   @Memoize(jestRootDir)
   babelJestFor(jestConfig: jest.ProjectConfig): jest.Transformer {
     // babel-jest is shipped with jest, no need to use the importer
@@ -99,6 +106,53 @@ export default class TsJestTransformer implements jest.Transformer {
     return result;
   }
 
+  // we can cache as for same instance the cache key won't change as soon as the path/content pair
+  // doesn't change
+  // TODO: find out if jest is already using this cache strategy and remove it if so
+  @Memoize((data: string, path: string) => `${path}::${data}`)
+  getCacheKey(
+    fileContent: string,
+    filePath: string,
+    jestConfigStr: string,
+    {
+      instrument = false,
+      rootDir,
+    }: { instrument?: boolean; rootDir?: string } = {},
+  ): string {
+    const CHAR0 = '\0';
+    // will be used as the hashing data source
+    const hashData: string[] = [];
+    const hashUpdate = (data: string) => hashData.push(data, CHAR0);
+
+    // add file path and its content
+    hashUpdate(filePath);
+    hashUpdate(fileContent);
+
+    // saniize and normalize jest config
+    const jestConfig: jest.ProjectConfig = JSON.parse(jestConfigStr);
+    jestConfig.rootDir = rootDir = jestRootDir({
+      rootDir: rootDir || jestConfig.rootDir,
+    });
+    const sanitizedJestConfig: jest.ProjectConfig = this.sanitizedJestConfigFor(
+      jestConfig,
+    );
+    // add jest config
+    hashUpdate(JSON.stringify(sanitizedJestConfig));
+    // add project's package.json
+    const projectPkg = closestPatckageJson(rootDir, true);
+    hashUpdate(projectPkg);
+    // add babel config if using babel jest
+    const babelConfig = this.babelConfigFor(jestConfig) || {};
+    hashUpdate(JSON.stringify(babelConfig));
+    // add tsconfig
+    const tsConfig = this.programFor(sanitizedJestConfig).parsedConfig;
+    hashUpdate(JSON.stringify(tsConfig));
+    // add instrument, even if we don't use it since `canInstrument` is false
+    hashUpdate(`instrument:${instrument ? 'on' : 'off'}`);
+
+    return sha1(...hashData);
+  }
+
   // TODO: use jest-config package to try to get current config and see if we are going to use babel jest or not
   // in which case we'd return `true` there:
   // get canInstrument() {}

test/ts-program.spec.ts → src/ts-program.spec.ts

@@ -1,9 +1,9 @@
-import TsProgram from '../src/ts-program';
+import TsProgram from './ts-program';
 import { resolve } from 'path';
-import { tsSourceMock, filePathMock } from './__helpers__/sources-mock';
+import * as fakers from './__helpers__/fakers';
 
-const path = filePathMock('path/to/file.ts');
-const content = tsSourceMock();
+const path = fakers.filePath('path/to/file.ts');
+const content = fakers.typescriptSource();
 
 describe('hoisting', () => {
   describe('without babel', () => {