Prova 0.2.0

Prova 🇸🇪

Prova is a next-generation testing framework for .NET, built for Speed, Native AOT, and Developer Experience.

Documentation IS the test output.

⚔️ The Kill Sheet

Why switch? Prova gives you the modern benefits of TUnit without the learning curve of a new syntax.

✨ Features

• ⚡ Zero Reflection / Native AOT: Fully compatible with PublishAot. No runtime discovery cost. Start time: 0ms.
• 🏃 True Parallelism: Test Classes run concurrently by default (Task.WhenAll), maximizing CPU usage.
• 🔌 MTP Ready: Fully supports the Microsoft Testing Platform. Works with dotnet test and TRX reporting.
• 🧙‍♂️ Magic Documentation: Your /// <summary> test comments are automatically extracted and displayed in the runner output.
• 📦 xUnit Parity: Don't rewrite your tests. Just change the runner.
  • [Fact], [Theory], [InlineData], [MemberData]
  • IClassFixture<T> (Isolated Fixtures)
  • IAsyncLifetime (Async Setup/Teardown)
  • [Trait] categories & filtering
  • Full Assert suite (Equal, Throws, Contains, Single, etc.)
• 🛡️ Enterprise Ready:
  • [Retry(3)]: Automatic retry logic for flaky tests.
  • [Parallel(max: 4)]: Explicit concurrency control to prevent thread pool choking.
  • [Focus]: Exclusive execution mode (Jest-style .only).

🛡️ The Nordic Suite

Prova is part of the Nordic Suite of developer tools. It is designed to work perfectly with Skugga, our AOT-native mocking library.

Learn more about Skugga Integration.

🚀 Quick Start

1. Install Prova:

   dotnet add package Prova
   

2. Write a Test:

   using Prova;
   
   public class CalculatorTests
   {
       [Fact]
       public void Add_ReturnsSum()
       {
           Assert.Equal(4, 2 + 2);
       }
   
       /// <summary>
       /// Simple division test ➗
       /// </summary>
       [Theory]
       [InlineData(10, 2, 5)]
       public void Divide_ReturnsQuotient(int a, int b, int expected)
       {
           Assert.Equal(expected, a / b);
       }
   }
   

3. Run:

   Option A: Direct Execution (Fastest / Recommended)

   dotnet run
   

   Option B: dotnet test (CI/CD / MTP) Prova fully supports the Microsoft Testing Platform. To use dotnet test, add a global.json to your solution root:

   {
       "test": {
           "runner": "Microsoft.Testing.Platform"
       }
   }
   

   Then run:

   dotnet test --project MyTestProject.csproj
   

🔌 Microsoft Testing Platform (MTP) Support

Prova is a first-class citizen in the modern .NET testing ecosystem. By integrating the Hybrid MTP Adapter, Prova provides:

• Full dotnet test integration via the Microsoft.Testing.Platform runner.
• TRX Report generation for Azure DevOps, GitHub Actions, and Jenkins.
• Code Coverage: Built-in support for --coverage to generate coverage.xml or Cobertura reports.
• In-process test execution with zero reflection overhead.

Check out the MTP Sample for a complete example.

📊 Code Coverage

To generate code coverage, use the --coverage flag:

# Generate Cobertura coverage report
dotnet run -- --coverage --coverage-output-format cobertura

# Report is generated in ./TestResults/*.cobertura.xml

Prova tests compile into a stand-alone Console Application, not a Class Library.

• 0ms Startup: We control the entry point (Main). No VSTest adapter overhead.
• MTP via dotnet run: Get the full Microsoft Testing Platform experience (TRX, etc.) without leaving the fast dotnet run inner loop.
• Debuggable: Just hit F5. It's just a console app!
• Cloud-Ready: Compile to a single Native AOT binary and dropship it to any container.

🛠️ Developer Experience

Focus Mode

Working on a specific test? Don't run the whole suite. Just add [Focus].

[Fact]
[Focus] // <--- Only this test will run!
public void MyNewFeature() { ... }

Why [Focus]?

• Zero Overhead: Unlike runtime filtering, Prova only generates code for focused tests. Skipped tests aren't even allocated.
• Convenience: No more complex CLI args like dotnet test --filter "FullyQualifiedName~MyTest". Just tag and run.

Retry Flaky Tests

Have a test that fails sporadically?

[Fact]
[Retry(3)] // <--- Retries up to 3 times before failing
public void NetworkTest() { ... }

Explicit Concurrency Control

Running 1000s of tests in parallel can choke the thread pool. Prova lets you bound parallelism per class or globally.

[Parallel(max: 4)] // <--- Only 4 tests in this class run concurrently
public class ResourceHeavyTests { ... }

Output Capture

Standard Console.WriteLine can be messy in parallel tests. Use ITestOutputHelper to capture logs per-test.

public class MyTests
{
    private readonly ITestOutputHelper _output;
    public MyTests(ITestOutputHelper output) => _output = output;

    [Fact]
    public void DebugSomething()
    {
        _output.WriteLine("This log appears attached to the test result! 📝");
    }
}

Dependency Injection (AOT-Safe)

Prova uses a compile-time "Explicit Factory" pattern for DI. No containers, no reflection.

1. Mark a static method as a factory with [TestDependency].
2. Inject the type into your test constructor.

public static class TestDependencies
{
    [TestDependency]
    public static IService CreateService() => new MyService(); // 🏭
}

public class MyTests
{
    private readonly IService _service;
    public MyTests(IService service) => _service = service; // 💉 Injected!

    [Fact]
    public void TestService() => Assert.NotNull(_service);
}

🤝 Contributing

We love contributions! Please read our CONTRIBUTING.md to get started.

📄 License

Prova is fully open source and licensed under MIT.