# Stryker CLI Commands and Configuration

## CLI Commands

### Basic Run

```bash
dotnet stryker
```

### Run with Project Specification

```bash
dotnet stryker --project MyProject.csproj
```

### Run with Test Project

```bash
dotnet stryker --project MyProject.csproj --test-project MyProject.Tests.csproj
```

### Run with Solution

```bash
dotnet stryker --solution MySolution.sln
```

### Run with Mutation Level

```bash
dotnet stryker --mutation-level Basic
dotnet stryker --mutation-level Standard
dotnet stryker --mutation-level Advanced
dotnet stryker --mutation-level Complete
```

### Run with Concurrency

```bash
dotnet stryker --concurrency 4
```

### Run with Reporters

```bash
dotnet stryker --reporter html
dotnet stryker --reporter json
dotnet stryker --reporter markdown
dotnet stryker --reporter progress
dotnet stryker --reporter cleartext
dotnet stryker --reporter dashboard
```

### Run with Thresholds

```bash
dotnet stryker --threshold-high 80 --threshold-low 60 --threshold-break 40
```

### Dry Run (No Mutations)

```bash
dotnet stryker --dry-run
```

### Filter Files

```bash
dotnet stryker --mutate "**/*.cs" --mutate "!**/Migrations/**"
```

### Filter Mutations

```bash
dotnet stryker --ignore-mutations Linq
dotnet stryker --ignore-mutations String
dotnet stryker --ignore-mutations Arithmetic
```

## Configuration File

Stryker uses `stryker-config.json` in the project root.

### Minimal Configuration

```json
{
  "stryker-config": {
    "project": "MyProject.csproj"
  }
}
```

### Standard Configuration

```json
{
  "stryker-config": {
    "project": "MyProject.csproj",
    "test-projects": ["MyProject.Tests.csproj"],
    "mutation-level": "Standard",
    "thresholds": {
      "high": 80,
      "low": 60,
      "break": 40
    },
    "reporters": ["progress", "html"],
    "concurrency": 4
  }
}
```

### Full Configuration

```json
{
  "stryker-config": {
    "project": "MyProject.csproj",
    "test-projects": ["MyProject.Tests.csproj", "MyProject.IntegrationTests.csproj"],
    "solution": "MySolution.sln",
    "mutation-level": "Advanced",
    "mutate": [
      "**/*.cs",
      "!**/Migrations/**",
      "!**/Generated/**"
    ],
    "ignore-mutations": [
      "Linq"
    ],
    "thresholds": {
      "high": 80,
      "low": 60,
      "break": 40
    },
    "reporters": ["progress", "html", "json"],
    "report-file-name": "mutation-report",
    "concurrency": 4,
    "log-level": "info",
    "coverage-analysis": "perTest",
    "disable-bail": false,
    "since": {
      "enabled": true,
      "target": "main"
    }
  }
}
```

## Key Options Reference

### Mutation Levels

| Level    | Mutators Included                                    |
|----------|------------------------------------------------------|
| Basic    | Core arithmetic, boolean, comparison                 |
| Standard | Basic + string, equality, logical operators          |
| Advanced | Standard + linq, method calls, block statements      |
| Complete | All available mutators                               |

### Reporters

| Reporter   | Output                                               |
|------------|------------------------------------------------------|
| html       | Interactive HTML report                              |
| json       | Machine-readable JSON                                |
| markdown   | Markdown summary                                     |
| progress   | Console progress bar                                 |
| cleartext  | Plain text console output                            |
| dashboard  | Stryker Dashboard upload                             |
| dots       | Minimal dot progress                                 |

### Coverage Analysis Modes

| Mode          | Description                                          |
|---------------|------------------------------------------------------|
| off           | Run all tests for each mutant                        |
| perTest       | Track which tests cover which mutants                |
| perTestInIsolation | Same as perTest but with process isolation      |

### Incremental Mutation Testing

Enable incremental mutation testing to only test changed code:

```json
{
  "stryker-config": {
    "since": {
      "enabled": true,
      "target": "main"
    }
  }
}
```

CLI equivalent:

```bash
dotnet stryker --since --since-target main
```

## CI Integration

### GitHub Actions

```yaml
- name: Run Stryker
  run: dotnet stryker --reporter json --reporter html
  continue-on-error: true

- name: Upload Mutation Report
  uses: actions/upload-artifact@v4
  with:
    name: mutation-report
    path: StrykerOutput/
```

### Azure Pipelines

```yaml
- script: dotnet stryker --reporter json --reporter html
  displayName: 'Run Mutation Tests'
  continueOnError: true

- task: PublishBuildArtifacts@1
  inputs:
    pathToPublish: 'StrykerOutput'
    artifactName: 'MutationReport'
```

## Output Directories

Default output: `StrykerOutput/<timestamp>/`

Custom output:

```bash
dotnet stryker --output ./reports/mutations
```

# Mutation Testing Patterns and Thresholds

## Threshold Guidelines

### Threshold Levels

| Threshold | Purpose                                              |
|-----------|------------------------------------------------------|
| high      | Score above this is green/excellent                  |
| low       | Score below this is yellow/warning                   |
| break     | Score below this fails the build                     |

### Recommended Thresholds by Context

#### New Critical Code

```json
{
  "thresholds": {
    "high": 90,
    "low": 80,
    "break": 70
  }
}
```

#### Established Production Code

```json
{
  "thresholds": {
    "high": 80,
    "low": 60,
    "break": 50
  }
}
```

#### Legacy Code Under Improvement

```json
{
  "thresholds": {
    "high": 70,
    "low": 50,
    "break": 30
  }
}
```

#### High-Risk Domain Logic

```json
{
  "thresholds": {
    "high": 95,
    "low": 90,
    "break": 85
  }
}
```

## Mutation Score Interpretation

### What Mutation Score Means

- **100%**: All mutants killed - every code mutation was detected by tests
- **80-99%**: Strong test suite - most mutations detected
- **60-79%**: Adequate coverage - significant gaps may exist
- **40-59%**: Weak coverage - many logic errors could go undetected
- **Below 40%**: Poor coverage - tests provide minimal fault detection

### Survived Mutants

A survived mutant means:

1. A code mutation was made
2. All tests still passed
3. The test suite did not detect the change

Common causes:

- Missing assertions
- Weak assertions (checking only part of behavior)
- Untested edge cases
- Dead code
- Equivalent mutants (mutation produces same behavior)

## Scoping Patterns

### Focus on Critical Paths

Target high-value code first:

```json
{
  "mutate": [
    "**/Domain/**/*.cs",
    "**/Core/**/*.cs",
    "!**/*Dto.cs",
    "!**/*Config.cs"
  ]
}
```

### Exclude Generated and Trivial Code

```json
{
  "mutate": [
    "**/*.cs",
    "!**/Migrations/**",
    "!**/Generated/**",
    "!**/obj/**",
    "!**/*.Designer.cs",
    "!**/GlobalUsings.cs"
  ]
}
```

### Ignore Low-Value Mutations

```json
{
  "ignore-mutations": [
    "Linq",
    "StringMethod"
  ]
}
```

## Mutation Categories

### Arithmetic Mutations

Original: `a + b`
Mutated: `a - b`, `a * b`, `a / b`

### Comparison Mutations

Original: `a > b`
Mutated: `a >= b`, `a < b`, `a == b`

### Boolean Mutations

Original: `true`
Mutated: `false`

Original: `a && b`
Mutated: `a || b`

### Equality Mutations

Original: `a == b`
Mutated: `a != b`

### Negation Mutations

Original: `!condition`
Mutated: `condition`

### Block Statement Mutations

Original: `if (x) { DoSomething(); }`
Mutated: `if (x) { }`

### Return Value Mutations

Original: `return value;`
Mutated: `return default;`

## Patterns for Surviving Mutants

### Pattern: Missing Boundary Tests

Mutation that survives:

```csharp
// Original: if (x >= 10)
// Mutated:  if (x > 10)
```

Fix: Add boundary test for `x = 10`.

### Pattern: Missing Null Checks

Mutation that survives:

```csharp
// Original: return item ?? default;
// Mutated:  return item;
```

Fix: Add test for null input.

### Pattern: Unchecked Error Paths

Mutation that survives:

```csharp
// Original: throw new ArgumentException();
// Mutated:  (removed)
```

Fix: Add test that expects the exception.

### Pattern: Side Effect Not Verified

Mutation that survives:

```csharp
// Original: _logger.Log(message);
// Mutated:  (removed)
```

Fix: Verify logger was called in test.

## Incremental Mutation Testing

### Run Only on Changed Code

```bash
dotnet stryker --since --since-target main
```

### Configuration for CI

```json
{
  "stryker-config": {
    "since": {
      "enabled": true,
      "target": "main"
    }
  }
}
```

### When to Use Full Mutation Runs

- Before major releases
- After significant refactoring
- When establishing baseline scores
- On scheduled nightly or weekly builds

## Performance Optimization

### Use Coverage Analysis

```json
{
  "coverage-analysis": "perTest"
}
```

This tracks which tests cover which code, running only relevant tests per mutant.

### Limit Concurrency Based on Resources

```json
{
  "concurrency": 4
}
```

Higher values use more memory and CPU.

### Use Baseline for Large Codebases

```json
{
  "baseline": {
    "enabled": true,
    "provider": "disk",
    "path": ".stryker-baseline"
  }
}
```

This caches results and only re-runs mutations for changed code.

## Anti-Patterns

### Do Not Chase 100% Everywhere

Diminishing returns on low-value code. Focus effort on:

- Domain logic
- Business rules
- Critical calculations
- Security-sensitive code

### Do Not Ignore Survived Mutants Blindly

Each survived mutant is a potential bug that tests would miss. Investigate before ignoring.

### Do Not Run Full Mutation Testing on Every PR

Too slow for large codebases. Use incremental mode or schedule full runs separately.

### Do Not Set Break Threshold Too High Initially

Start conservative and increase as test quality improves. A failing mutation gate on every PR creates frustration without value.

## Workflow Integration

### Recommended PR Workflow

1. Run incremental mutation testing on changed files
2. Report results without failing the build
3. Track trends over time

### Recommended Release Workflow

1. Run full mutation testing before release branches
2. Use break threshold to enforce quality gate
3. Generate reports for team review

### Recommended Nightly Workflow

1. Run full mutation testing on main branch
2. Generate trend reports
3. Open issues for significant score drops

# Stryker.NET

## Open/Free Status

- open source
- free to use

## Install

```bash
dotnet tool install -g dotnet-stryker
```

Or as a local tool:

```bash
dotnet new tool-manifest
dotnet tool install dotnet-stryker
```

## Verify First

Before installing, check whether the repo already has a local or global Stryker tool:

```bash
rg --files -g '.config/dotnet-tools.json'
dotnet tool list --local
dotnet tool list --global
command -v dotnet-stryker
```

## Common Usage

```bash
dotnet stryker
```

## CI Fit

- best for critical libraries, domain logic, and less frequently changing hotspots
- usually too expensive for the fastest PR gate in large solutions

## When Not To Use

- when the test suite is already flaky or too slow
- when simple build, test, and coverage gates are still not stable

## Sources

- [Stryker.NET](https://github.com/stryker-mutator/stryker-net)