@systemfsoftware/stryker-js-typescript-checker 0.1.0

package/test/integration/e2e-plugin-entry.it.spec.ts

@@ -0,0 +1,153 @@
+import path from 'path'
+import { fileURLToPath } from 'url'
+
+import { CheckStatus } from '@stryker-mutator/api/check'
+import type { Mutant, StrykerOptions } from '@stryker-mutator/api/core'
+import type { Logger, LoggerFactoryMethod } from '@stryker-mutator/api/logging'
+import { commonTokens } from '@stryker-mutator/api/plugin'
+import type { Injector, PluginContext } from '@stryker-mutator/api/plugin'
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+
+import { HybridFileSystem } from '../../src/fs/hybrid-file-system.js'
+import { createTypescriptChecker } from '../../src/index.js'
+import * as pluginTokens from '../../src/plugin-tokens.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: () => {},
+  }
+}
+
+interface InjectableFunctionWithTokens {
+  inject?: readonly string[]
+  (...args: unknown[]): unknown
+}
+
+interface InjectableClassWithTokens {
+  inject?: readonly string[]
+  new(...args: unknown[]): unknown
+}
+
+function createInjector(tsconfigFile: string): Injector<PluginContext> {
+  const context: Record<string, unknown> = {
+    [commonTokens.getLogger]: (): Logger => createLogger(),
+    [commonTokens.logger]: createLogger(),
+    [commonTokens.options]: {
+      tsconfigFile,
+      typescriptChecker: { prioritizePerformanceOverAccuracy: true },
+    } as unknown as StrykerOptions,
+    [commonTokens.target]: undefined,
+    [commonTokens.injector]: undefined,
+  }
+
+  const resolveToken = (token: string): unknown => {
+    if (!(token in context)) {
+      throw new Error(`Missing injection token: ${token}`)
+    }
+    return context[token]
+  }
+
+  const injectArgs = (inject: readonly string[]): unknown[] => inject.map(resolveToken)
+
+  const self: Injector<PluginContext> = {
+    provideFactory: (token, factory, _scope) => {
+      const f = factory as InjectableFunctionWithTokens
+      context[token] = f(...injectArgs(f.inject ?? []))
+      return self
+    },
+    provideClass: (token, Class, _scope) => {
+      const C = Class as InjectableClassWithTokens
+      context[token] = new C(...injectArgs(C.inject ?? []))
+      return self
+    },
+    injectClass: (Class) => {
+      const C = Class as InjectableClassWithTokens
+      return new C(...injectArgs(C.inject ?? [])) as never
+    },
+    injectFunction: (fn) => {
+      const f = fn as InjectableFunctionWithTokens
+      return f(...injectArgs(f.inject ?? [])) as never
+    },
+    resolve: (token) => resolveToken(token as string) as never,
+    provideValue: (token, value) => {
+      context[token] = value
+      return self
+    },
+    createChildInjector: () => self,
+    dispose: async () => {},
+  }
+
+  return self
+}
+
+interface ClosableChecker {
+  tsCompiler: { close(): void }
+}
+
+const todoSource =
+  'export interface ITodo {\n  name: string;\n  description: string;\n  completed: boolean;\n}\n\nclass Todo implements ITodo {\n  constructor(public name: string, public description: string, public completed: boolean) { }\n}\n\nexport class TodoList {\n  public static allTodos: Todo[] = [];\n  createTodoItem(name: string, description: string) {\n    let newItem = new Todo(name, description, false);\n    let totalCount: number = TodoList.allTodos.push(newItem);\n    return totalCount;\n  }\n\n  allTodoItems(): ITodo[] {\n    return TodoList.allTodos;\n  }\n}\n\n'
+
+function createMutant(replacement: string, id: string): Mutant {
+  const findText = 'TodoList.allTodos.push(newItem)'
+  const lines = todoSource.split('\n')
+  const lineNumber = lines.findIndex((line) => line.includes(findText))
+  const textColumn = lines[lineNumber]!.indexOf(findText)
+  return {
+    id,
+    fileName: resolveTestResource('src', 'todo.ts'),
+    mutatorName: 'foo-mutator',
+    location: {
+      start: { line: lineNumber, column: textColumn },
+      end: { line: lineNumber, column: textColumn + findText.length },
+    },
+    replacement,
+  } as unknown as Mutant
+}
+
+describe('Typescript checker plugin entry', () => {
+  let sut: TypescriptChecker
+
+  beforeEach(() => {
+    const injector = createInjector(resolveTestResource('tsconfig.json'))
+    sut = createTypescriptChecker(injector)
+    return sut.init()
+  })
+
+  afterEach(() => {
+    ;(sut as unknown as ClosableChecker).tsCompiler.close()
+  })
+
+  it('should report Passed for a mutant without compile errors', async () => {
+    const mutant = createMutant('newItem ? 42 : 43', 'e2e-pass')
+    const actual = await sut.check([mutant])
+    expect(actual).toEqual({ 'e2e-pass': { status: CheckStatus.Passed } })
+  })
+
+  it('should report CompileError for a mutant that introduces a type error', async () => {
+    const mutant = createMutant('TodoList.allTodos.push("invalid")', 'e2e-fail')
+    const actual = await sut.check([mutant])
+    expect(actual['e2e-fail']?.status).toBe(CheckStatus.CompileError)
+  })
+})

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

@@ -0,0 +1,146 @@
+import fs from 'fs'
+import path from 'path'
+import { fileURLToPath } from 'url'
+
+import { CheckStatus } from '@stryker-mutator/api/check'
+import type { Location, Mutant, StrykerOptions } from '@stryker-mutator/api/core'
+import type { Logger } from '@stryker-mutator/api/logging'
+import { afterEach, beforeEach, 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-references',
+) 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 project with project references', () => {
+  let sut: TypescriptChecker
+
+  beforeEach(() => {
+    sut = createChecker(resolveTestResource('tsconfig.root.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', async () => {
+    const mutant = createMutant('job.ts', 'Starting job', 'stryker was here')
+    const actualResult = await sut.check([mutant])
+    expect(actualResult[mutant.id]!).toEqual({ status: CheckStatus.Passed })
+  })
+
+  it('should allow unused local variables (override options)', async () => {
+    const mutant = createMutant(
+      'job.ts',
+      'toUpperCase(logText)',
+      'toUpperCase("")',
+    )
+    const actual = await sut.check([mutant])
+    expect(actual[mutant.id]!).toEqual({ status: CheckStatus.Passed })
+  })
+
+  it('should create multiple groups if reference between project', async () => {
+    const mutantInSourceProject = createMutant(
+      'job.ts',
+      'Starting job',
+      '',
+      '42',
+    )
+    const mutantInProjectWithReference = createMutant(
+      'text.ts',
+      'toUpperCase()',
+      'toLowerCase()',
+      '43',
+    )
+    const mutantOutsideOfReference = createMutant(
+      'math.ts',
+      'array.length',
+      '1',
+      '44',
+    )
+    const result = await sut.group([
+      mutantInSourceProject,
+      mutantInProjectWithReference,
+      mutantOutsideOfReference,
+    ])
+    expect(result).toHaveLength(2)
+  })
+})
+
+const fileContents: Record<string, string> = Object.freeze({
+  ['index.ts']: fs.readFileSync(resolveTestResource('src', 'index.ts'), 'utf8'),
+  ['job.ts']: fs.readFileSync(resolveTestResource('src', 'job.ts'), 'utf8'),
+  ['math.ts']: fs.readFileSync(resolveTestResource('utils', 'math.ts'), 'utf8'),
+  ['text.ts']: fs.readFileSync(resolveTestResource('utils', 'text.ts'), 'utf8'),
+})
+
+function createMutant(
+  fileName: 'index.ts' | 'job.ts' | 'math.ts' | 'text.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/project-with-ts-buildinfo.it.spec.ts

@@ -0,0 +1,92 @@
+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

@@ -0,0 +1,263 @@
+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 { afterEach, beforeEach, 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',
+  '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',
+    )
+  })
+})
+
+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,
+  }
+}