feat: added typescript testcaferc configuration file support

src/cli/cli.js

@@ -85,6 +85,7 @@ async function runTests (argParser) {
         v8Flags,
         disableCrossDomain,
         esm,
+        compilerOptions,
     } = opts;
 
     const testCafe = await createTestCafe({
@@ -102,6 +103,7 @@ async function runTests (argParser) {
         v8Flags,
         disableCrossDomain,
         esm,
+        compilerOptions,
     });
 
     const correctedBrowsersAndSources = await correctBrowsersAndSources(argParser, testCafe.configuration);
@@ -189,4 +191,3 @@ async function listBrowsers (providerName) {
         error(err);
     }
 })();
-

src/compiler/test-file/api-based.js

@@ -83,7 +83,11 @@ export default class APIBasedTestFileCompilerBase extends TestFileCompilerBase {
             mod._compile(code, filename);
 
             cacheProxy.stopExternalCaching();
+
+            return mod;
         }
+
+        return Promise.resolve();
     }
 
     _compileCode (code, filename) {
@@ -191,7 +195,7 @@ export default class APIBasedTestFileCompilerBase extends TestFileCompilerBase {
         return global.fixture && global.test;
     }
 
-    async _runCompiledCode (compiledCode, filename) {
+    async _runCompiledTestCode (compiledCode, filename) {
         const testFile = new TestFile(filename);
 
         this._addGlobalAPI(testFile);
@@ -230,7 +234,7 @@ export default class APIBasedTestFileCompilerBase extends TestFileCompilerBase {
     }
 
     execute (compiledCode, filename) {
-        return this._runCompiledCode(compiledCode, filename);
+        return this._runCompiledTestCode(compiledCode, filename);
     }
 
     async compile (code, filename) {

src/compiler/test-file/formats/typescript/compiler.ts

@@ -267,4 +267,22 @@ export default class TypeScriptTestFileCompiler extends APIBasedTestFileCompiler
     public getSupportedExtension (): string[] {
         return [Extensions.ts, Extensions.tsx];
     }
+
+    async compileConfiguration (filename: string) : Promise<object | null> {
+        let compiledConfigurationModule = null;
+
+        const [compiledCode] = await this.precompile([{ code: '', filename }]);
+
+        if (compiledCode) {
+            this._setupRequireHook({ });
+
+            compiledConfigurationModule = await this._execAsModule(compiledCode, filename);
+
+            this._removeRequireHook();
+
+            return compiledConfigurationModule?.exports;
+        }
+
+        return null;
+    }
 }

src/configuration/configuration-base.ts

@@ -154,24 +154,15 @@ export default class Configuration {
         return this._defaultPaths;
     }
 
-    public async _load (): Promise<null | object> {
+    public async _load (customCompilerOptions?: object): Promise<null | object> {
         if (!this.defaultPaths?.length)
             return null;
 
         const configs = await Promise.all(this.defaultPaths.map(async filePath => {
             if (!await this._isConfigurationFileExists(filePath))
                 return { filePath, options: null };
 
-            let options = null as object | null;
-
-            if (this._isJSConfiguration(filePath))
-                options = this._readJsConfigurationFileContent(filePath);
-            else {
-                const configurationFileContent = await this._readConfigurationFileContent(filePath);
-
-                if (configurationFileContent)
-                    options = this._parseConfigurationFileContent(configurationFileContent, filePath);
-            }
+            const options = await this._readConfigurationOptions(filePath, customCompilerOptions);
 
             return { filePath, options };
         }));
@@ -189,6 +180,19 @@ export default class Configuration {
         return existedConfigs[0].options;
     }
 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    protected async _readConfigurationOptions (filePath: string, customCompilerOptions?: object): Promise<object | null> {
+        if (this._isJSConfiguration(filePath))
+            return this._readJsConfigurationFileContent(filePath);
+
+        const configurationFileContent = await this._readConfigurationFileContent(filePath);
+
+        if (configurationFileContent)
+            return this._parseConfigurationFileContent(configurationFileContent, filePath);
+
+        return null;
+    }
+
     protected async _isConfigurationFileExists (filePath = this.filePath): Promise<boolean> {
         try {
             await stat(filePath);
@@ -202,7 +206,7 @@ export default class Configuration {
         }
     }
 
-    private static _hasExtension (filePath: string | undefined, extention: string): boolean {
+    protected static _hasExtension (filePath: string | undefined, extention: string): boolean {
         return !!filePath && extname(filePath) === extention;
     }
 

src/configuration/formats.ts

@@ -2,6 +2,7 @@ enum Extensions {
     js = '.js',
     json = '.json',
     cjs = '.cjs',
+    ts = '.ts',
 }
 
 export default Extensions;

src/configuration/testcafe-configuration.ts

@@ -45,6 +45,7 @@ import { RUNTIME_ERRORS } from '../errors/types';
 import { LOCALHOST_NAMES } from '../utils/localhost-names';
 import { BrowserConnectionGatewayOptions } from '../browser/connection/gateway';
 import { getValidHostname } from './utils';
+import TypeScriptTestFileCompiler from '../compiler/test-file/formats/typescript/compiler';
 
 const BASE_CONFIGURATION_FILENAME = '.testcaferc';
 const CONFIGURATION_FILENAMES     = (Object.keys(Extensions) as Array<keyof typeof Extensions>).map(ext => `${BASE_CONFIGURATION_FILENAME}${Extensions[ext]}`);
@@ -100,7 +101,7 @@ export default class TestCafeConfiguration extends Configuration {
     public async init (options?: Dictionary<object>): Promise<void> {
         await super.init();
 
-        const opts = await this._load();
+        const opts = await this._load(options);
 
         if (opts) {
             this._options = Configuration._fromObj(opts);
@@ -337,4 +338,29 @@ export default class TestCafeConfiguration extends Configuration {
             return hostname;
         });
     }
+
+    protected async _readConfigurationOptions (filePath: string, customCompilerOptions?: object): Promise<object | null> {
+        if (this._isTSConfiguration(filePath)) {
+            const compilerOptions = (customCompilerOptions as Dictionary<object>)?.compilerOptions;
+
+            return this._readTsConfigurationFileContent(filePath, compilerOptions);
+        }
+
+        return super._readConfigurationOptions(filePath);
+    }
+
+    protected _isTSConfiguration (filePath = this.filePath): boolean {
+        return Configuration._hasExtension(filePath, Extensions.ts);
+    }
+
+    public async _readTsConfigurationFileContent (filePath = this.filePath, compilerOptions?: TypeScriptCompilerOptions): Promise<object | null> {
+        if (!filePath)
+            return null;
+
+        delete require.cache[filePath];
+
+        const compiler = new TypeScriptTestFileCompiler(compilerOptions, {});
+
+        return compiler.compileConfiguration(filePath);
+    }
 }

src/configuration/typescript-configuration.ts

@@ -41,7 +41,7 @@ export default class TypescriptConfiguration extends Configuration {
     }
 
     public async init (customCompilerOptions?: object): Promise<void> {
-        const opts = await this._load() as TypescriptConfigurationOptions;
+        const opts = await this._load(customCompilerOptions) as TypescriptConfigurationOptions;
 
         if (opts && opts.compilerOptions) {
             const parsedOpts = this._parseOptions(opts);

src/index.js

@@ -25,7 +25,7 @@ async function getConfiguration (args) {
         // It should be removed in future TestCafe versions.
         // All new APIs should be enabled through the configuration object in the upper clause.
         // Please do not add new APIs here.
-        const [hostname, port1, port2, ssl, developmentMode, retryTestPages, cache, configFile] = args;
+        const [hostname, port1, port2, ssl, developmentMode, retryTestPages, cache, configFile, compilerOptions] = args;
 
         configuration = new TestCafeConfiguration(configFile);
 
@@ -37,6 +37,7 @@ async function getConfiguration (args) {
             developmentMode,
             retryTestPages,
             cache,
+            compilerOptions,
         });
     }
 

test/server/compiler-test.js

@@ -1011,7 +1011,7 @@ describe('Compiler', function () {
         });
 
         it('Should raise an error if test file has a TypeScript error', function () {
-            const testfile = posixResolve('test/server/data/test-suites/typescript-compile-errors/testfile.ts');
+            const testfile = posixResolve('test/server/data/test-suites/typescript-compile-errors/testfile.ts').toLowerCase();
 
             return compile(testfile)
                 .then(function () {

test/server/configuration-test.js

@@ -925,6 +925,168 @@ describe('TypeScriptConfiguration', function () {
             await del(configuration.defaultPaths);
         });
 
+        describe('Custom typescript config file', function () {
+            const CUSTOM_TESTCAFE_CONFIG_FILE_PATH = 'custom11.testcaferc.ts';
+            const CUSTOM_TS_CONFIG_FILE_PATH       = 'custom11.tsconfig.json';
+
+            const OPTIONS = {
+                'hostname': '123.456.789',
+                'port1':    1234,
+                'port2':    5678,
+                'src':      'path1/folder',
+                'browser':  'edge',
+            };
+
+            function createTestCafeTypescriptConfigurationFile (filePath) {
+                fs.writeFileSync(filePath, `
+    const fs         = require('fs');
+    const path       = require('path');
+    const { nanoid } = require('nanoid');
+    const jsCustomModule = require('./test/server/data/configuration/module/module.js');
+    const tsCustomModule = require('./test/server/data/configuration/typescript-module/module.ts');
+    \n
+    const foo = (p) => {};
+
+    \n
+    module.exports = ${JSON.stringify(OPTIONS)}`);
+            }
+
+            beforeEach(() => {
+                createTestCafeTypescriptConfigurationFile(CUSTOM_TESTCAFE_CONFIG_FILE_PATH);
+            });
+
+            it('Custom ts config path is used', async () => {
+                configuration = new TestCafeConfiguration(CUSTOM_TESTCAFE_CONFIG_FILE_PATH);
+
+                await configuration.init();
+
+                expect(pathUtil.basename(configuration.filePath)).eql(CUSTOM_TESTCAFE_CONFIG_FILE_PATH);
+                expect(configuration.getOption('hostname')).eql(OPTIONS.hostname);
+                expect(configuration.getOption('port1')).eql(OPTIONS.port1);
+                expect(configuration.getOption('port2')).eql(OPTIONS.port2);
+                expect(configuration.getOption('src')).eql([OPTIONS.src]);
+                expect(configuration.getOption('browser')).eql(OPTIONS.browser);
+            });
+
+            it('Custom ts config is not well-formed', async () => {
+                let message = '';
+
+                fs.writeFileSync(CUSTOM_TESTCAFE_CONFIG_FILE_PATH, 'const a: string = 1;');
+
+                configuration = new TestCafeConfiguration(CUSTOM_TESTCAFE_CONFIG_FILE_PATH);
+
+                try {
+                    await configuration.init();
+                }
+                catch (err) {
+                    message = err.message;
+                }
+
+                expect(message).contains('custom11.testcaferc.ts (1, 7): ' +
+                                         'Type \'number\' is not assignable to type \'string\'.\n',
+                );
+            });
+
+            it('Custom ts config path is used and compiler options defined in tsconfig.json', async () => {
+                const tsOptions = JSON.stringify({
+                    compilerOptions: {
+                        noImplicitAny: true,
+                    },
+                });
+
+                fs.writeFileSync(CUSTOM_TS_CONFIG_FILE_PATH, tsOptions);
+
+                configuration = new TestCafeConfiguration(CUSTOM_TESTCAFE_CONFIG_FILE_PATH);
+
+                let err;
+
+                try {
+                    await configuration.init({
+                        compilerOptions: {
+                            configPath: CUSTOM_TS_CONFIG_FILE_PATH,
+                        },
+                    });
+                }
+                catch (e) {
+                    err = e;
+                }
+
+                expect(err.message).contains('custom11.testcaferc.ts (9, 18): Parameter \'p\' implicitly has an \'any\' type.');
+            });
+
+            it('Custom ts config path is used and compiler options passed as argument', async () => {
+                configuration = new TestCafeConfiguration(CUSTOM_TESTCAFE_CONFIG_FILE_PATH);
+
+                let err;
+
+                try {
+                    await configuration.init({
+                        compilerOptions: {
+                            options: {
+                                noImplicitAny: true,
+                            },
+                        },
+                    });
+                }
+                catch (e) {
+                    err = e;
+                }
+
+                expect(err.message).contains('custom11.testcaferc.ts (9, 18): Parameter \'p\' implicitly has an \'any\' type.');
+            });
+
+            it('Custom ts config path is used and custom compiler path passed as argument', async () => {
+                configuration = new TestCafeConfiguration(CUSTOM_TESTCAFE_CONFIG_FILE_PATH);
+
+                let err;
+
+                try {
+                    await configuration.init({
+                        compilerOptions: {
+                            customCompilerModulePath: 'non-existing-ts-compiler',
+                        },
+                    });
+                }
+                catch (e) {
+                    err = e;
+                }
+
+                expect(err.message).contains('Cannot load the TypeScript compiler.\n' +
+                                             'Cannot find module \'non-existing-ts-compiler\'',
+                );
+            });
+
+            it('Custom ts config is used with compiler options passed as arguments and tsconfig.json', async () => {
+                const tsOptions = JSON.stringify({
+                    compilerOptions: {
+                        noImplicitAny: false,
+                    },
+                });
+
+                fs.writeFileSync(CUSTOM_TS_CONFIG_FILE_PATH, tsOptions);
+
+                configuration = new TestCafeConfiguration(CUSTOM_TESTCAFE_CONFIG_FILE_PATH);
+
+                let err;
+
+                try {
+                    await configuration.init({
+                        compilerOptions: {
+                            configPath: CUSTOM_TS_CONFIG_FILE_PATH,
+                            options:    {
+                                noImplicitAny: true,
+                            },
+                        },
+                    });
+                }
+                catch (e) {
+                    err = e;
+                }
+
+                expect(err.message).contains('custom11.testcaferc.ts (9, 18): Parameter \'p\' implicitly has an \'any\' type.');
+            });
+        });
+
         it('Custom config path is used', () => {
             const customConfigFile = 'custom11.testcaferc.json';
 

test/server/data/configuration/module/module.js

@@ -0,0 +1,7 @@
+function module() {
+    return 'module';
+}
+
+module.exports = {
+    module: module,
+}