@systemfsoftware/stryker-js-typescript-checker 1.2.2 → 1.3.0

package/test/integration/project-with-ts-buildinfo.it.spec.ts

@@ -1,92 +0,0 @@
-import fs from 'fs'
-import path from 'path'
-import { fileURLToPath } from 'url'
-
-import type { Location, Mutant, StrykerOptions } from '@stryker-mutator/api/core'
-import type { Logger } from '@stryker-mutator/api/logging'
-import { describe, expect, it } from 'vitest'
-
-import { HybridFileSystem } from '../../src/fs/hybrid-file-system.js'
-import { TypescriptChecker } from '../../src/typescript-checker.js'
-import { TypescriptCompiler } from '../../src/typescript-compiler.js'
-
-const resolveTestResource = path.resolve.bind(
-  path,
-  path.dirname(fileURLToPath(import.meta.url)),
-  '..',
-  '..',
-  'testResources',
-  'project-with-ts-buildinfo',
-) as unknown as typeof path.resolve
-
-function createLogger(): Logger {
-  return {
-    isTraceEnabled: () => false,
-    isDebugEnabled: () => false,
-    isInfoEnabled: () => false,
-    isWarnEnabled: () => false,
-    isErrorEnabled: () => false,
-    isFatalEnabled: () => false,
-    trace: () => {},
-    debug: () => {},
-    info: () => {},
-    warn: () => {},
-    error: () => {},
-    fatal: () => {},
-  }
-}
-
-function createChecker(tsconfigFile: string): TypescriptChecker {
-  const options = {
-    tsconfigFile,
-    typescriptChecker: { prioritizePerformanceOverAccuracy: true },
-  } as unknown as StrykerOptions
-  const logger = createLogger()
-  const fileSystem = new HybridFileSystem()
-  const compiler = new TypescriptCompiler(logger, options, fileSystem)
-  return new TypescriptChecker(logger, options, compiler)
-}
-
-describe('project-with-ts-buildinfo', () => {
-  it('should load project on init', async () => {
-    const sut = createChecker(resolveTestResource('tsconfig.json'))
-    await sut.init()
-    const group = await sut.group([createMutant('src/index.ts', '', '')])
-    expect(group).toHaveLength(1)
-    // @ts-expect-error private close method
-    sut.tsCompiler.close()
-  })
-})
-
-const fileContents: Record<string, string> = Object.freeze({
-  ['src/index.ts']: fs.readFileSync(
-    resolveTestResource('src', 'index.ts'),
-    'utf8',
-  ),
-})
-
-function createMutant(
-  fileName: 'src/index.ts',
-  findText: string,
-  replacement: string,
-  id = '42',
-  offset = 0,
-): Mutant {
-  const lines = fileContents[fileName]!.split('\n')
-  const lineNumber = lines.findIndex((l) => l.includes(findText))
-  if (lineNumber === -1) {
-    throw new Error(`Cannot find ${findText} in ${fileName}`)
-  }
-  const textColumn = lines[lineNumber]!.indexOf(findText)
-  const location: Location = {
-    start: { line: lineNumber, column: textColumn + offset },
-    end: { line: lineNumber, column: textColumn + findText.length },
-  }
-  return {
-    id,
-    fileName: resolveTestResource('src', fileName),
-    mutatorName: 'foo-mutator',
-    location,
-    replacement,
-  }
-}

package/test/integration/single-project.it.spec.ts

@@ -1,298 +0,0 @@
-import fs from 'fs'
-import path from 'path'
-import { fileURLToPath } from 'url'
-
-import { CheckStatus } from '@stryker-mutator/api/check'
-import type { FailedCheckResult } from '@stryker-mutator/api/check'
-import type { Location, Mutant, StrykerOptions } from '@stryker-mutator/api/core'
-import type { Logger } from '@stryker-mutator/api/logging'
-import { Either } from 'effect'
-import { afterEach, beforeEach, describe, expect, it } from 'vitest'
-
-import { HybridFileSystem } from '../../src/fs/hybrid-file-system.js'
-import { overrideOptions, parseTsConfig } from '../../src/tsconfig-helpers.js'
-import { TypescriptChecker } from '../../src/typescript-checker.js'
-import { TypescriptCompiler } from '../../src/typescript-compiler.js'
-
-const resolveTestResource = path.resolve.bind(
-  path,
-  path.dirname(fileURLToPath(import.meta.url)),
-  '..',
-  '..',
-  'testResources',
-  'single-project',
-) as unknown as typeof path.resolve
-
-function createLogger(): Logger {
-  return {
-    isTraceEnabled: () => false,
-    isDebugEnabled: () => false,
-    isInfoEnabled: () => false,
-    isWarnEnabled: () => false,
-    isErrorEnabled: () => false,
-    isFatalEnabled: () => false,
-    trace: () => {},
-    debug: () => {},
-    info: () => {},
-    warn: () => {},
-    error: () => {},
-    fatal: () => {},
-  }
-}
-
-function createChecker(tsconfigFile: string): TypescriptChecker {
-  const options = {
-    tsconfigFile,
-    typescriptChecker: { prioritizePerformanceOverAccuracy: true },
-  } as unknown as StrykerOptions
-  const logger = createLogger()
-  const fileSystem = new HybridFileSystem()
-  const compiler = new TypescriptCompiler(logger, options, fileSystem)
-  return new TypescriptChecker(logger, options, compiler)
-}
-
-describe('Typescript checker on a single project', () => {
-  let sut: TypescriptChecker
-
-  beforeEach(() => {
-    sut = createChecker(resolveTestResource('tsconfig.json'))
-    return sut.init()
-  })
-
-  afterEach(() => {
-    // @ts-expect-error private close method
-    sut.tsCompiler.close()
-  })
-
-  it('should not write output to disk', () => {
-    expect(
-      fs.existsSync(resolveTestResource('dist')),
-      'Output was written to disk!',
-    ).toBe(false)
-  })
-
-  it('should be able to validate a mutant that does not result in an error', async () => {
-    const mutant = createMutant(
-      'todo.ts',
-      'TodoList.allTodos.push(newItem)',
-      'newItem? 42: 43',
-      '42',
-    )
-    const actual = await sut.check([mutant])
-    expect(actual).toEqual({ '42': { status: CheckStatus.Passed } })
-  })
-
-  it('should be able invalidate a mutant that does result in a compile error', async () => {
-    const mutant = createMutant(
-      'todo.ts',
-      'TodoList.allTodos.push(newItem)',
-      '"This should not be a string 🙄"',
-      'mutId',
-    )
-    const actual = await sut.check([mutant])
-    expect(actual['mutId']!.status).toBe(CheckStatus.CompileError)
-    expect((actual['mutId'] as FailedCheckResult).reason).toContain(
-      'todo.ts(15,9): error TS2322',
-    )
-  })
-
-  it('should be able validate a mutant that does not result in a compile error after a compile error', async () => {
-    const mutantCompileError = createMutant(
-      'todo.ts',
-      'TodoList.allTodos.push(newItem)',
-      '"This should not be a string 🙄"',
-    )
-    const mutantWithoutError = createMutant(
-      'todo.ts',
-      'return TodoList.allTodos',
-      '[]',
-      'mut42',
-      7,
-    )
-
-    await sut.check([mutantCompileError])
-    const actual = await sut.check([mutantWithoutError])
-
-    expect(actual).toEqual({ mut42: { status: CheckStatus.Passed } })
-  })
-
-  it('should be able to invalidate a mutant that results in an error in a different file', async () => {
-    const actual = await sut.check([
-      createMutant('todo.ts', 'return totalCount', '', '42'),
-    ])
-    expect(actual['42']!.status).toBe(CheckStatus.CompileError)
-    expect((actual['42'] as FailedCheckResult).reason).toContain(
-      'todo.spec.ts(4,7): error TS2322',
-    )
-  })
-
-  it('should be able to validate a mutant after a mutant in a different file resulted in a transpile error', async () => {
-    await sut.check([createMutant('todo.ts', 'return totalCount', '')])
-    const result = await sut.check([
-      createMutant(
-        'todo.spec.ts',
-        "'Mow lawn'",
-        "'this is valid, right?'",
-        'id42',
-      ),
-    ])
-
-    expect(result).toEqual({ id42: { status: CheckStatus.Passed } })
-  })
-
-  it('should be allow mutations in unrelated files', async () => {
-    const result = await sut.check([
-      createMutant('not-type-checked.js', 'bar', 'baz', 'id1'),
-    ])
-
-    expect(result).toEqual({ id1: { status: CheckStatus.Passed } })
-  })
-
-  it('should allow unused local variables (override options)', async () => {
-    const mutant = createMutant(
-      'todo.ts',
-      'TodoList.allTodos.push(newItem)',
-      '42',
-      'id45',
-    )
-    const actual = await sut.check([mutant])
-    expect(actual).toEqual({ id45: { status: CheckStatus.Passed } })
-  })
-
-  it('should be able invalidate 2 mutants that do result in a compile errors', async () => {
-    const mutant = createMutant(
-      'todo.ts',
-      'TodoList.allTodos.push(newItem)',
-      '"This should not be a string 🙄"',
-      'mutId',
-    )
-    const mutant2 = createMutant(
-      'counter.ts',
-      'return this.currentNumber',
-      'return "This should not return a string 🙄"',
-      'mutId2',
-    )
-    const actual = await sut.check([mutant, mutant2])
-    expect(actual['mutId']!.status).toBe(CheckStatus.CompileError)
-    expect(actual['mutId2']!.status).toBe(CheckStatus.CompileError)
-    expect((actual['mutId'] as FailedCheckResult).reason).toContain(
-      'todo.ts(15,9): error TS2322',
-    )
-    expect((actual['mutId2'] as FailedCheckResult).reason).toContain(
-      'counter.ts(7,5): error TS2322',
-    )
-  })
-
-  it('should be able invalidate 2 mutants that do result in a compile error in file above', async () => {
-    const mutant = createMutant(
-      'errorInFileAbove2Mutants/todo.ts',
-      'TodoList.allTodos.push(newItem)',
-      '"This should not be a string 🙄"',
-      'mutId',
-    )
-    const mutant2 = createMutant(
-      'errorInFileAbove2Mutants/counter.ts',
-      'return (this.currentNumber += numberToIncrementBy)',
-      'return "This should not return a string 🙄"',
-      'mutId2',
-    )
-    const actual = await sut.check([mutant, mutant2])
-    expect(actual['mutId']!.status).toBe(CheckStatus.CompileError)
-    expect(actual['mutId2']!.status).toBe(CheckStatus.CompileError)
-    expect((actual['mutId'] as FailedCheckResult).reason).toContain(
-      'todo.ts(15,9): error TS2322',
-    )
-    expect((actual['mutId2'] as FailedCheckResult).reason).toContain(
-      'errorInFileAbove2Mutants/todo-counter.ts(7,7): error TS2322',
-    )
-  })
-
-  it('should compile the fixture source files discovered via the ** include glob', async () => {
-    // The fixture tsconfig selects its inputs via `include: ["src/**/*.ts"]`. If a comment
-    // stripper corrupted the glob (the `/**/` inside it looks like an empty block comment),
-    // TypeScript would find no input files and abort init with TS18003, so this assertion
-    // pins the end-to-end regression against the real checker path.
-    const mutant = createMutant(
-      'errorInFileAbove2Mutants/todo.ts',
-      'TodoList.allTodos.push(newItem)',
-      '"This should not be a string 🙄"',
-      'glob-pin',
-    )
-    const actual = await sut.check([mutant])
-    expect(actual['glob-pin']?.status).toBe(CheckStatus.CompileError)
-    expect((actual['glob-pin'] as FailedCheckResult).reason).toContain(
-      'todo.ts(15,9): error TS2322',
-    )
-  })
-
-  it('should preserve the fixture $schema URL and ** glob in the config produced by overrideOptions', () => {
-    // `$schema` holds a `//`-bearing string and `include` holds a `**` glob: the two shapes a
-    // naive comment stripper mangles. The compiler feeds the output of `overrideOptions` to
-    // TypeScript, so this asserts both survive byte-for-byte into that config.
-    const tsconfigFile = resolveTestResource('tsconfig.json')
-    const content = fs.readFileSync(tsconfigFile, 'utf8')
-    const parsed = parseTsConfig(tsconfigFile, content)
-    if (Either.isLeft(parsed)) {
-      throw new Error(`Expected fixture tsconfig to parse, got: ${parsed.left.reason}`)
-    }
-    const config = overrideOptions(parsed.right, false)
-    expect(config).toContain('"$schema":"https://json.schemastore.org/tsconfig"')
-    expect(config).toContain('"include":["src/**/*.ts"]')
-  })
-})
-
-const fileContents: Record<string, string> = Object.freeze({
-  ['errorInFileAbove2Mutants/todo.ts']: fs.readFileSync(
-    resolveTestResource('src', 'errorInFileAbove2Mutants', 'todo.ts'),
-    'utf8',
-  ),
-  ['errorInFileAbove2Mutants/counter.ts']: fs.readFileSync(
-    resolveTestResource('src', 'errorInFileAbove2Mutants', 'counter.ts'),
-    'utf8',
-  ),
-  ['todo.ts']: fs.readFileSync(resolveTestResource('src', 'todo.ts'), 'utf8'),
-  ['counter.ts']: fs.readFileSync(
-    resolveTestResource('src', 'counter.ts'),
-    'utf8',
-  ),
-  ['todo.spec.ts']: fs.readFileSync(
-    resolveTestResource('src', 'todo.spec.ts'),
-    'utf8',
-  ),
-  ['not-type-checked.js']: fs.readFileSync(
-    resolveTestResource('src', 'not-type-checked.js'),
-    'utf8',
-  ),
-})
-
-function createMutant(
-  fileName:
-    | 'counter.ts'
-    | 'errorInFileAbove2Mutants/counter.ts'
-    | 'errorInFileAbove2Mutants/todo.ts'
-    | 'not-type-checked.js'
-    | 'todo.spec.ts'
-    | 'todo.ts',
-  findText: string,
-  replacement: string,
-  id = '42',
-  offset = 0,
-): Mutant {
-  const lines = fileContents[fileName]!.split('\n')
-  const lineNumber = lines.findIndex((line) => line.includes(findText))
-  if (lineNumber === -1) {
-    throw new Error(`Cannot find ${findText} in ${fileName}`)
-  }
-  const textColumn = lines[lineNumber]!.indexOf(findText)
-  const location: Location = {
-    start: { line: lineNumber, column: textColumn + offset },
-    end: { line: lineNumber, column: textColumn + findText.length },
-  }
-  return {
-    id,
-    fileName: resolveTestResource('src', fileName),
-    mutatorName: 'foo-mutator',
-    location,
-    replacement,
-  }
-}

package/test/integration/tsconfig-helpers.it.spec.ts

@@ -1,199 +0,0 @@
-import { mkdtempSync, rmSync, writeFileSync } from 'fs'
-import { tmpdir } from 'os'
-import path from 'path'
-
-import { Either } from 'effect'
-import { afterEach, describe, expect, it } from 'vitest'
-
-import {
-  determineBuildModeEnabled,
-  overrideOptions,
-  parseTsConfig,
-  TsConfigParseError,
-} from '../../src/tsconfig-helpers.js'
-
-function expectRight<A, E>(either: Either.Either<A, E>): A {
-  if (Either.isLeft(either)) {
-    throw new Error(`Expected a Right result, got a Left: ${String(either.left)}`)
-  }
-  return either.right
-}
-
-describe('parseTsConfig', () => {
-  it('should preserve a glob pattern in include exactly', () => {
-    const config = expectRight(
-      parseTsConfig('tsconfig.json', '{"include":["src/**/*.workflow.ts"]}'),
-    )
-    expect(config).toEqual({ include: ['src/**/*.workflow.ts'] })
-  })
-
-  it('should round-trip a $schema URL unchanged', () => {
-    const config = expectRight(
-      parseTsConfig('tsconfig.json', '{"$schema":"https://json.schemastore.org/tsconfig"}'),
-    )
-    expect(config).toEqual({
-      $schema: 'https://json.schemastore.org/tsconfig',
-    })
-  })
-
-  it('should round-trip a Windows path and an escaped quote unchanged', () => {
-    const config = expectRight(
-      parseTsConfig(
-        'tsconfig.json',
-        '{"paths":{"a":["C:\\\\x//y"]},"description":"he said \\"hi\\""}',
-      ),
-    )
-    expect(config).toEqual({
-      paths: { a: ['C:\\x//y'] },
-      description: 'he said "hi"',
-    })
-  })
-
-  it('should accept trailing commas in nested objects and arrays', () => {
-    const config = expectRight(
-      parseTsConfig(
-        'tsconfig.json',
-        '{"compilerOptions":{"strict":true,},"include":["a.ts","b.ts",]}',
-      ),
-    )
-    expect(config).toEqual({
-      compilerOptions: { strict: true },
-      include: ['a.ts', 'b.ts'],
-    })
-  })
-
-  it('should accept content prefixed with a BOM', () => {
-    const withoutBom = expectRight(
-      parseTsConfig('tsconfig.json', '{"compilerOptions":{"strict":true}}'),
-    )
-    const withBom = expectRight(
-      parseTsConfig('tsconfig.json', '\uFEFF{"compilerOptions":{"strict":true}}'),
-    )
-    expect(withBom).toEqual(withoutBom)
-  })
-
-  it('should strip line and block comments', () => {
-    const config = expectRight(
-      parseTsConfig(
-        'tsconfig.json',
-        '{\n// a line comment\n"a": 1,\n/* a block comment */\n"b": 2\n}',
-      ),
-    )
-    expect(config).toEqual({ a: 1, b: 2 })
-  })
-
-  it('should preserve unknown nested keys inside compilerOptions', () => {
-    const config = expectRight(
-      parseTsConfig(
-        'tsconfig.json',
-        '{"compilerOptions":{"strict":true,"experimentalDecorators":true}}',
-      ),
-    )
-    expect(config.compilerOptions).toEqual({
-      strict: true,
-      experimentalDecorators: true,
-    })
-  })
-
-  it('should return a Left for a malformed document', () => {
-    const result = parseTsConfig('tsconfig.json', '{ "a": }')
-    expect(Either.isLeft(result)).toBe(true)
-    if (Either.isLeft(result)) {
-      expect(result.left).toBeInstanceOf(TsConfigParseError)
-      expect(result.left.file).toBe('tsconfig.json')
-      expect(result.left.reason.length).toBeGreaterThan(0)
-    }
-  })
-
-  it('should return a Left for truncated input', () => {
-    for (const truncated of ['{', '{"a":']) {
-      expect(Either.isLeft(parseTsConfig('tsconfig.json', truncated))).toBe(true)
-    }
-  })
-
-  it('should return a Left for an unterminated block comment', () => {
-    const result = parseTsConfig('tsconfig.json', '{"a":1,/* never closed')
-    expect(Either.isLeft(result)).toBe(true)
-  })
-
-  it('should return a Left for a bare string root (not a config object)', () => {
-    const result = parseTsConfig('tsconfig.json', '"just a string"')
-    expect(Either.isLeft(result)).toBe(true)
-    if (Either.isLeft(result)) {
-      expect(result.left).toBeInstanceOf(TsConfigParseError)
-      expect(result.left.file).toBe('tsconfig.json')
-      expect(result.left.reason.length).toBeGreaterThan(0)
-    }
-  })
-
-  it('should return a Left when references is not an array', () => {
-    const result = parseTsConfig('tsconfig.json', '{"references":"nope"}')
-    expect(Either.isLeft(result)).toBe(true)
-    if (Either.isLeft(result)) {
-      expect(result.left).toBeInstanceOf(TsConfigParseError)
-      expect(result.left.reason.length).toBeGreaterThan(0)
-    }
-  })
-})
-
-describe('overrideOptions', () => {
-  it('should apply the compiler-option overrides to an empty config', () => {
-    const parsed = JSON.parse(overrideOptions({}, false))
-    expect(parsed.compilerOptions).toMatchObject({
-      allowUnreachableCode: true,
-      noEmit: true,
-      target: 'es2022',
-      moduleResolution: 'bundler',
-    })
-  })
-
-  it('should preserve unknown top-level keys and unknown compilerOptions through to the output', () => {
-    const config = expectRight(
-      parseTsConfig(
-        'tsconfig.json',
-        '{"include":["src/**/*.ts"],"compilerOptions":{"strict":true,"experimentalDecorators":true}}',
-      ),
-    )
-    const output = JSON.parse(overrideOptions(config, false))
-    expect(output.include).toEqual(['src/**/*.ts'])
-    expect(output.compilerOptions.strict).toBe(true)
-    expect(output.compilerOptions.experimentalDecorators).toBe(true)
-  })
-})
-
-describe('determineBuildModeEnabled', () => {
-  let tempDir: string | undefined
-
-  afterEach(() => {
-    if (tempDir !== undefined) {
-      rmSync(tempDir, { recursive: true, force: true })
-    }
-  })
-
-  function createTsconfig(content: string): string {
-    tempDir = mkdtempSync(path.join(tmpdir(), 'tsconfig-helpers-'))
-    const tsconfigPath = path.join(tempDir, 'tsconfig.json')
-    writeFileSync(tsconfigPath, content)
-    return tsconfigPath
-  }
-
-  it('should return true when the config has references', () => {
-    const tsconfigPath = createTsconfig('{"references":[{"path":"./a"}]}')
-    expect(determineBuildModeEnabled(tsconfigPath)).toBe(true)
-  })
-
-  it('should return false when the config has no references', () => {
-    const tsconfigPath = createTsconfig('{"compilerOptions":{"strict":true}}')
-    expect(determineBuildModeEnabled(tsconfigPath)).toBe(false)
-  })
-
-  it('should return false when the config is a bare string instead of throwing a TypeError', () => {
-    const tsconfigPath = createTsconfig('"just a string"')
-    expect(determineBuildModeEnabled(tsconfigPath)).toBe(false)
-  })
-
-  it('should return false when references is not an array', () => {
-    const tsconfigPath = createTsconfig('{"references":"nope"}')
-    expect(determineBuildModeEnabled(tsconfigPath)).toBe(false)
-  })
-})

package/test/integration/typescript-checkers-errors.it.spec.ts

@@ -1,112 +0,0 @@
-import path from 'path'
-import { fileURLToPath } from 'url'
-
-import type { StrykerOptions } from '@stryker-mutator/api/core'
-import type { Logger } from '@stryker-mutator/api/logging'
-import { describe, expect, it, vi } from 'vitest'
-
-import { HybridFileSystem } from '../../src/fs/hybrid-file-system.js'
-import { TypescriptChecker } from '../../src/typescript-checker.js'
-import { TypescriptCompiler } from '../../src/typescript-compiler.js'
-
-const resolveTestResource = path.resolve.bind(
-  path,
-  path.dirname(fileURLToPath(import.meta.url)),
-  '..',
-  '..',
-  'testResources',
-  'errors',
-) as unknown as typeof path.resolve
-
-function createLogger(warn: Logger['warn'] = () => {}): Logger {
-  return {
-    isTraceEnabled: () => false,
-    isDebugEnabled: () => false,
-    isInfoEnabled: () => false,
-    isWarnEnabled: () => false,
-    isErrorEnabled: () => false,
-    isFatalEnabled: () => false,
-    trace: () => {},
-    debug: () => {},
-    info: () => {},
-    warn,
-    error: () => {},
-    fatal: () => {},
-  }
-}
-
-function createChecker(
-  tsconfigFile: string,
-  logger: Logger = createLogger(),
-): TypescriptChecker {
-  const options = {
-    tsconfigFile,
-    typescriptChecker: { prioritizePerformanceOverAccuracy: true },
-  } as unknown as StrykerOptions
-  const fileSystem = new HybridFileSystem()
-  const compiler = new TypescriptCompiler(logger, options, fileSystem)
-  return new TypescriptChecker(logger, options, compiler)
-}
-
-describe('Typescript checker errors', () => {
-  it('should reject initialization if initial compilation failed', async () => {
-    const sut = createChecker(
-      resolveTestResource('compile-error', 'tsconfig.json'),
-    )
-    await expect(sut.init()).rejects.toThrow(
-      'Typescript error(s) found in dry run compilation:',
-    )
-    await expect(sut.init()).rejects.toThrow(
-      'testResources/errors/compile-error/add.ts(2,3): error TS2322:',
-    )
-  }, 30_000)
-
-  it('should reject initialization if tsconfig was invalid', async () => {
-    const sut = createChecker(
-      resolveTestResource('invalid-tsconfig', 'tsconfig.json'),
-    )
-    await expect(sut.init()).rejects.toThrow(
-      'Typescript error(s) found in dry run compilation:',
-    )
-    await expect(sut.init()).rejects.toThrow(
-      'testResources/errors/invalid-tsconfig/tsconfig.json(1,1): error TS1005:',
-    )
-  })
-
-  it('should log a warning naming the tsconfig path and the skipped-overrides consequence when parsing falls back', async () => {
-    const warn = vi.fn()
-    const sut = createChecker(
-      resolveTestResource('invalid-tsconfig', 'tsconfig.json'),
-      createLogger(warn),
-    )
-
-    await expect(sut.init()).rejects.toThrow(
-      'testResources/errors/invalid-tsconfig/tsconfig.json(1,1): error TS1005:',
-    )
-
-    expect(warn).toHaveBeenCalled()
-    const warnings = warn.mock.calls
-      .map((call) => call.join(' '))
-      .join('\n')
-    expect(warnings).toContain(
-      'testResources/errors/invalid-tsconfig/tsconfig.json',
-    )
-    expect(warnings.toLowerCase()).toContain(
-      'compiler-option overrides and project-reference walking were skipped',
-    )
-  })
-
-  it("should reject when tsconfig file doesn't exist", async () => {
-    const sut = createChecker(
-      resolveTestResource('empty-dir', 'tsconfig.json'),
-    )
-    await expect(sut.init()).rejects.toThrow(
-      `The tsconfig file does not exist at: "${
-        resolveTestResource(
-          'empty-dir',
-          'tsconfig.json',
-        )
-      }". Please configure the tsconfig file in your stryker.conf file using "tsconfigFile"`,
-    )
-  })
-})