How does dotnet test work, and how do you filter tests, collect code coverage and publish results in CI?

1. The moving parts (VSTest mode, the default)

 dotnet test Orders.slnx -c Release
   |
   +-- build each test project (unless --no-build)
   |
   v
 test platform (vstest.console)
   |
   +-- for EACH test project and EACH target framework:
   |      start a separate testhost process
   |         loads Microsoft.NET.Test.Sdk + the adapter package
   |         (xunit.runner.visualstudio / NUnit3TestAdapter / MSTest.TestAdapter)
   |         adapter discovers tests by reflection, then runs them
   |
   +-- data collectors attach to the testhost
   |      coverage (coverlet / Microsoft Code Coverage), blame (dumps)
   |
   +-- loggers receive results
   |      console, trx, junit (via a logger package), html
   |
   v
 exit code: 0 = all passed, non-zero = a failure or a run error

The separate testhost process isolates tests from the runner. It is how collectors attach, how a crash in a test doesn't take down the runner, and how blame can dump a hung host.

2. Filter syntax in full

--filter "<property><operator><value>", combined with & (and), | (or) and parentheses.

Examples:

--filter "Category=Unit"
--filter "FullyQualifiedName~Orders.Domain"
--filter "Category!=Slow&FullyQualifiedName~Pricing"
--filter "(Category=Unit|Category=Contract)&FullyQualifiedName!~Legacy"

Characters such as (, ), & and | inside a value must be escaped with \, and in a shell the whole filter must be quoted.

3. Results: loggers

Publish the result files as a pipeline step that runs even when tests fail (condition: always() in Azure Pipelines, if: always() in GitHub Actions), otherwise the failures you most need to see are never published.

4. Coverage

 dotnet test --collect "XPlat Code Coverage"
    |  coverlet.collector instruments the assemblies under test
    v
 TestResults/<guid>/coverage.cobertura.xml   (one per test project)
    |
    v
 ReportGenerator: merge all files, produce HTML + summary
    |
    v
 publish as a pipeline artefact or coverage tab, compare with main

Configure includes and excludes (generated code, migrations, test projects) in a .runsettings file rather than on the command line. Treat coverage as a map of untested risk, not a number to hit.

5. Hangs and crashes

Without these, a hung test simply times out the whole CI job with no clue. With them, you get the test name and a dump you can open in Visual Studio or dotnet-dump.

6. Parallelism

Tests that share a database, a port or static state fail randomly when run in parallel. Isolate them (separate databases or containers per test class) rather than turning parallelism off everywhere.

7. Run settings

A .runsettings file, passed with --settings tests.runsettings, keeps options in the repo:

A developer can then reproduce exactly what CI ran with the same file.

8. Microsoft.Testing.Platform mode (.NET 10)

 VSTest mode (default)                     MTP mode (opt in via global.json)
 dotnet test --> vstest.console            dotnet test --> runs each test project's
             --> testhost per project                      own executable directly
             --> adapter                   (the test framework IS the host)

Switch deliberately: confirm every test framework in the repo supports MTP, update pipeline arguments, and check your CI still picks up results.

9. Performance

• Keep unit tests free of I/O so thousands run in seconds.
• Put slow integration tests behind a filter and run them as a separate, parallel job.
• Use --no-build after one solution build.
• Watch the slowest tests in the TRX results and fix them before the suite becomes a bottleneck.

10. Security

Integration tests often need secrets. Get them from the pipeline's secret store as environment variables, never from a committed appsettings.Test.json. TRX files, console logs and blame dumps can contain data from test environments, so treat them as internal artefacts with limited retention.

11. .NET 11 awareness

Microsoft.Testing.Platform is where new test features are going. Watch the .NET 11 SDK notes for changes to the default runner before relying on them.

12. Try it yourself

1. Create the project in the code example and run dotnet test.
2. Run only unit tests with --filter "Category=Unit", then only integration tests.
3. Add --logger trx --results-directory ./TestResults and open the TRX file.
4. Add --collect "XPlat Code Coverage", find coverage.cobertura.xml, and turn it into HTML with ReportGenerator.
5. Add a test that awaits Task.Delay(Timeout.Infinite) and run with --blame-hang-timeout 30s; find the dump and the name of the hung test.
6. Make the test fail and check the exit code with echo $? (bash) or $LASTEXITCODE (PowerShell).
7. Add "test": { "runner": "Microsoft.Testing.Platform" } to global.json in a scratch copy with an MTP-enabled test project and compare the options.

Create a test project and run it with filters, results and coverage:

dotnet new xunit -n Orders.Tests -o tests/Orders.Tests -f net10.0
dotnet test tests/Orders.Tests --filter "Category=Unit" --logger trx --results-directory ./TestResults
dotnet test tests/Orders.Tests --collect "XPlat Code Coverage" --blame-hang-timeout 5m

tests/Orders.Tests/PricingTests.cs:

namespace Orders.Tests;

public static class Pricing
{
    public static decimal WithGst(decimal amount) => Math.Round(amount * 1.10m, 2, MidpointRounding.AwayFromZero);
}

public class PricingTests
{
    [Fact]
    [Trait("Category", "Unit")]
    public void WithGst_adds_ten_percent() => Assert.Equal(110.00m, Pricing.WithGst(100m));

    [Theory]
    [Trait("Category", "Unit")]
    [InlineData(0.05, 0.06)]
    [InlineData(19.99, 21.99)]
    public void WithGst_rounds_to_cents(decimal amount, decimal expected) =>
        Assert.Equal(expected, Pricing.WithGst(amount));

    [Fact]
    [Trait("Category", "Integration")]
    public async Task Integration_tests_are_filtered_separately()
    {
        await Task.Delay(10);
        Assert.True(true);
    }
}

Turn coverage into an HTML report (ReportGenerator as a local tool):

dotnet new tool-manifest
dotnet tool install dotnet-reportgenerator-globaltool
dotnet reportgenerator -reports:"tests/**/coverage.cobertura.xml" -targetdir:coverage-report -reporttypes:Html