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

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

@@ -1,218 +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,
-    })
-  })
-
-  it('should not inject a moduleResolution that contradicts the consumer module', () => {
-    const config = expectRight(
-      parseTsConfig('tsconfig.json', '{"compilerOptions":{"module":"NodeNext"}}'),
-    )
-    const output = JSON.parse(overrideOptions(config, false))
-    expect(output.compilerOptions.module).toBe('NodeNext')
-    expect(output.compilerOptions.moduleResolution).toBeUndefined()
-  })
-
-  it('should preserve the consumer target and moduleResolution verbatim', () => {
-    const config = expectRight(
-      parseTsConfig(
-        'tsconfig.json',
-        '{"compilerOptions":{"target":"es2024","moduleResolution":"NodeNext"}}',
-      ),
-    )
-    const output = JSON.parse(overrideOptions(config, false))
-    expect(output.compilerOptions.target).toBe('es2024')
-    expect(output.compilerOptions.moduleResolution).toBe('NodeNext')
-  })
-
-  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"`,
-    )
-  })
-})

package/test/unit/fs/hybrid-file-system.spec.ts

@@ -1,109 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { HybridFileSystem } from '../../../src/fs/hybrid-file-system.js'
-
-describe('HybridFileSystem', () => {
-  function createSut(): HybridFileSystem {
-    return new HybridFileSystem()
-  }
-
-  describe('writeFile', () => {
-    it('should create a new in-memory file', () => {
-      const sut = createSut()
-      sut.writeFile('add.js', 'a + b')
-      const file = sut.getFile('add.js')
-      expect(file).toBeTruthy()
-      expect(file!.content).toBe('a + b')
-      expect(file!.fileName).toBe('add.js')
-    })
-
-    it('should override an existing file', () => {
-      const sut = createSut()
-      sut.writeFile('add.js', 'a + b')
-      sut.writeFile('add.js', 'a - b')
-      const file = sut.getFile('add.js')
-      expect(file!.content).toBe('a - b')
-    })
-
-    it('should convert path separator to forward slashes', () => {
-      const sut = createSut()
-      sut.writeFile('test\\foo\\a.js', 'a')
-      const actual = sut.getFile('test/foo/a.js')
-      expect(actual).toBeTruthy()
-      expect(actual!.content).toBe('a')
-    })
-  })
-
-  describe('readFile', () => {
-    it('should return in-memory content', () => {
-      const sut = createSut()
-      sut.writeFile('foo.js', 'in-memory')
-      expect(sut.readFile('foo.js')).toBe('in-memory')
-    })
-
-    it('should return undefined for non-mutated files to allow disk fallback', () => {
-      const sut = createSut()
-      expect(sut.readFile('some-file-that-is-not-tracked.js')).toBeUndefined()
-    })
-
-    it('should return null for buildinfo files', () => {
-      const sut = createSut()
-      expect(sut.readFile('cache.tsbuildinfo')).toBeNull()
-    })
-
-    it('should return the tsconfig override when present', () => {
-      const sut = createSut()
-      sut.tsConfigOverrides.set('/project/tsconfig.json', '{"compilerOptions":{}}')
-      expect(sut.readFile('/project/tsconfig.json')).toBe('{"compilerOptions":{}}')
-    })
-  })
-
-  describe('fileExists', () => {
-    it('should return true for in-memory files', () => {
-      const sut = createSut()
-      sut.writeFile('foo.js', '')
-      expect(sut.fileExists('foo.js')).toBe(true)
-    })
-
-    it('should return false for buildinfo files', () => {
-      const sut = createSut()
-      expect(sut.fileExists('cache.tsbuildinfo')).toBe(false)
-    })
-
-    it('should return undefined for unknown files', () => {
-      const sut = createSut()
-      expect(sut.fileExists('unknown.js')).toBeUndefined()
-    })
-  })
-
-  describe('mutateFile / resetFile', () => {
-    it('should mutate a file and reset it afterwards', () => {
-      const sut = createSut()
-      sut.writeFile('add.js', 'function add(a: number, b: number) { return a + b; }')
-      sut.mutateFile('add.js', {
-        location: {
-          start: { line: 0, column: 42 },
-          end: { line: 0, column: 49 },
-        },
-        replacement: 'a - b',
-      })
-      expect(sut.readFile('add.js')).toContain('a - b')
-
-      sut.resetFile('add.js')
-      expect(sut.readFile('add.js')).toContain('a + b')
-    })
-  })
-
-  describe('existsInMemory', () => {
-    it('should return true if file exists in memory', () => {
-      const sut = createSut()
-      sut.writeFile('test-file', '')
-      expect(sut.existsInMemory('test-file')).toBe(true)
-    })
-
-    it('should return false if file does not exist in memory', () => {
-      const sut = createSut()
-      expect(sut.existsInMemory('test-file')).toBe(false)
-    })
-  })
-})

package/test/unit/grouping/create-groups.spec.ts

@@ -1,122 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { createGroups } from '../../../src/grouping/create-groups.js'
-import { TSFileNode } from '../../../src/grouping/ts-file-node.js'
-
-function factoryMutant(fileName: string, id: string) {
-  return {
-    id,
-    fileName,
-    mutatorName: 'foo-mutator',
-    replacement: '',
-    location: {
-      start: { line: 0, column: 0 },
-      end: { line: 0, column: 0 },
-    },
-  }
-}
-
-describe('createGroups', () => {
-  it('single mutant should create single group', () => {
-    const mutants = [factoryMutant('a.js', 'mutant-1')]
-    const nodes = new Map<string, TSFileNode>([
-      ['a.js', new TSFileNode('a.js', [], [])],
-    ])
-    const groups = createGroups(mutants, nodes)
-    expect(groups).toHaveLength(1)
-    expect(groups[0]!).toHaveLength(1)
-    expect(groups[0]![0]).toBe('mutant-1')
-  })
-
-  it('two mutants in different files without reference to each other should create single group', () => {
-    const mutants = [factoryMutant('a.js', '1'), factoryMutant('b.js', '2')]
-    const nodes = new Map<string, TSFileNode>([
-      ['a.js', new TSFileNode('a.js', [], [])],
-      ['b.js', new TSFileNode('b.js', [], [])],
-    ])
-    const groups = createGroups(mutants, nodes)
-    expect(groups).toHaveLength(1)
-    expect(groups[0]![0]).toBe('1')
-    expect(groups[0]![1]).toBe('2')
-  })
-
-  it('two mutants in different files with reference to each other should create 2 groups', () => {
-    const mutants = [factoryMutant('a.js', '1'), factoryMutant('b.js', '2')]
-    const nodeA = new TSFileNode('a.js', [], [])
-    const nodeB = new TSFileNode('b.js', [nodeA], [])
-    const nodes = new Map<string, TSFileNode>([
-      [nodeA.fileName, nodeA],
-      [nodeB.fileName, nodeB],
-    ])
-    const groups = createGroups(mutants, nodes)
-    expect(groups).toHaveLength(2)
-    expect(groups[0]![0]).toBe('1')
-    expect(groups[1]![0]).toBe('2')
-  })
-
-  it('two mutants in different files with circular dependency to each other should create 2 groups', () => {
-    const mutants = [factoryMutant('a.js', '1'), factoryMutant('b.js', '2')]
-    const nodeA = new TSFileNode('a.js', [], [])
-    const nodeB = new TSFileNode('b.js', [nodeA], [])
-    nodeA.parents.push(nodeB)
-    const nodes = new Map<string, TSFileNode>([
-      [nodeA.fileName, nodeA],
-      [nodeB.fileName, nodeB],
-    ])
-    const groups = createGroups(mutants, nodes)
-    expect(groups).toHaveLength(2)
-    expect(groups[0]![0]).toBe('1')
-    expect(groups[1]![0]).toBe('2')
-  })
-
-  it('two mutants in same file should create 2 groups', () => {
-    const mutants = [factoryMutant('a.js', '1'), factoryMutant('a.js', '2')]
-    const nodeA = new TSFileNode('a.js', [], [])
-    const nodes = new Map<string, TSFileNode>([[nodeA.fileName, nodeA]])
-    const groups = createGroups(mutants, nodes)
-    expect(groups).toHaveLength(2)
-    expect(groups[0]![0]).toBe('1')
-    expect(groups[1]![0]).toBe('2')
-  })
-
-  it('complex graph should contain multiple groups', () => {
-    const mutants = [
-      factoryMutant('a.js', '1'),
-      factoryMutant('b.js', '2'),
-      factoryMutant('c.js', '3'),
-      factoryMutant('d.js', '4'),
-      factoryMutant('e.js', '5'),
-      factoryMutant('f.js', '6'),
-    ]
-    const nodeA = new TSFileNode('a.js', [], [])
-    const nodeB = new TSFileNode('b.js', [nodeA], [])
-    const nodeC = new TSFileNode('c.js', [nodeA], [])
-    const nodeD = new TSFileNode('d.js', [nodeC], [])
-    const nodeE = new TSFileNode('e.js', [nodeA], [])
-    const nodeF = new TSFileNode('f.js', [nodeE, nodeD], [])
-    const nodes = new Map<string, TSFileNode>([
-      [nodeA.fileName, nodeA],
-      [nodeB.fileName, nodeB],
-      [nodeC.fileName, nodeC],
-      [nodeD.fileName, nodeD],
-      [nodeE.fileName, nodeE],
-      [nodeF.fileName, nodeF],
-    ])
-    const groups = createGroups(mutants, nodes)
-    expect(groups).toHaveLength(4)
-    expect(groups[0]![0]).toBe('1')
-    expect(groups[1]![0]).toBe('2')
-    expect(groups[1]![1]).toBe('3')
-    expect(groups[1]![2]).toBe('5')
-    expect(groups[2]![0]).toBe('4')
-    expect(groups[3]![0]).toBe('6')
-  })
-
-  it('should throw error when node is not in graph', () => {
-    const mutants = [factoryMutant('a.js', '1')]
-    const nodeA = new TSFileNode('.js', [], [])
-    const nodes = new Map<string, TSFileNode>([[nodeA.fileName, nodeA]])
-
-    expect(() => createGroups(mutants, nodes)).toThrow('Node not in graph: a.js')
-  })
-})

package/test/unit/grouping/ts-file-node.spec.ts

@@ -1,132 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { TSFileNode } from '../../../src/grouping/ts-file-node.js'
-
-describe('TSFileNode', () => {
-  describe('getAllParentReferencesIncludingSelf', () => {
-    it('without parent should return array of 1 node', () => {
-      const node = new TSFileNode('NodeA', [], [])
-      expect(node.getAllParentReferencesIncludingSelf()).toHaveLength(1)
-    })
-
-    it('with 1 parent should return array of 2 nodes', () => {
-      const node = new TSFileNode('NodeA', [new TSFileNode('', [], [])], [])
-      expect(node.getAllParentReferencesIncludingSelf()).toHaveLength(2)
-    })
-
-    it('with recursive depth of 2 should return 3 nodes', () => {
-      const node = new TSFileNode(
-        'NodeA',
-        [new TSFileNode('', [new TSFileNode('', [], [])], [])],
-        [],
-      )
-      expect(node.getAllParentReferencesIncludingSelf()).toHaveLength(3)
-    })
-
-    it('with recursive depth of 2 and multiple parents should return 4 nodes', () => {
-      const node = new TSFileNode(
-        'NodeA',
-        [
-          new TSFileNode(
-            '',
-            [new TSFileNode('', [], []), new TSFileNode('', [], [])],
-            [],
-          ),
-        ],
-        [],
-      )
-      expect(node.getAllParentReferencesIncludingSelf()).toHaveLength(4)
-    })
-
-    it('with circular dependency should skip circular dependency node', () => {
-      const nodeA = new TSFileNode('NodeA', [], [])
-      const nodeC = new TSFileNode('NodeB', [nodeA], [])
-      const nodeB = new TSFileNode('NodeB', [nodeC], [])
-      nodeA.parents.push(nodeB)
-      expect(nodeA.getAllParentReferencesIncludingSelf()).toHaveLength(3)
-    })
-  })
-
-  describe('getAllChildReferencesIncludingSelf', () => {
-    it('without child should return array of 1 node', () => {
-      const node = new TSFileNode('NodeA', [], [])
-      expect(node.getAllChildReferencesIncludingSelf()).toHaveLength(1)
-    })
-
-    it('with 1 child should return array of 2 nodes', () => {
-      const node = new TSFileNode('NodeA', [], [new TSFileNode('', [], [])])
-      expect(node.getAllChildReferencesIncludingSelf()).toHaveLength(2)
-    })
-
-    it('with recursive depth of 2 should return 3 nodes', () => {
-      const node = new TSFileNode(
-        'NodeA',
-        [],
-        [new TSFileNode('', [], [new TSFileNode('', [], [])])],
-      )
-      expect(node.getAllChildReferencesIncludingSelf()).toHaveLength(3)
-    })
-
-    it('with recursive depth of 2 and multiple children should return 4 nodes', () => {
-      const node = new TSFileNode(
-        'NodeA',
-        [],
-        [
-          new TSFileNode(
-            '',
-            [],
-            [new TSFileNode('', [], []), new TSFileNode('', [], [])],
-          ),
-        ],
-      )
-      expect(node.getAllChildReferencesIncludingSelf()).toHaveLength(4)
-    })
-  })
-
-  describe('getMutantsWithReferenceToChildrenOrSelf', () => {
-    it('with single mutant in file should return 1 mutant', () => {
-      const node = new TSFileNode('NodeA.js', [], [])
-      const mutants = [createMutant('NodeA.js')]
-      expect(node.getMutantsWithReferenceToChildrenOrSelf(mutants)).toHaveLength(1)
-    })
-
-    it('with single mutant in child should return 1 mutant', () => {
-      const node = new TSFileNode('NodeA.js', [], [])
-      const nodeB = new TSFileNode('NodeB.js', [], [])
-      node.children.push(nodeB)
-      const mutants = [createMutant('NodeB.js')]
-      expect(node.getMutantsWithReferenceToChildrenOrSelf(mutants)).toHaveLength(1)
-    })
-
-    it('should not create endless loop', () => {
-      const node = new TSFileNode('NodeA.js', [], [])
-      node.children = [node]
-
-      const mutants = [createMutant('NodeA.js')]
-
-      expect(node.getMutantsWithReferenceToChildrenOrSelf(mutants)).toHaveLength(1)
-    })
-
-    it('should find mutant with backward slashes and forward slashes', () => {
-      const node = new TSFileNode('path/NodeA.js', [], [])
-      node.children = [node]
-
-      const mutants = [createMutant('path/NodeA.js'), createMutant('path\\NodeA.js')]
-
-      expect(node.getMutantsWithReferenceToChildrenOrSelf(mutants)).toHaveLength(2)
-    })
-  })
-})
-
-function createMutant(fileName: string) {
-  return {
-    fileName,
-    id: '0',
-    replacement: '-',
-    location: {
-      start: { line: 1, column: 1 },
-      end: { line: 1, column: 1 },
-    },
-    mutatorName: '',
-  }
-}

package/testResources/errors/compile-error/add.ts

@@ -1,3 +0,0 @@
-function add(a: number, b: number): string {
-  return a + b
-}