NetEvolve.Extensions.TUnit is a .NET library that provides consistent test categorization attributes for TUnit, enabling seamless integration with multi-framework test solutions. This library allows teams to apply standardized test categories across different testing frameworks, making test filtering and execution management uniform and predictable.
🎯 Overview
This package is part of the NetEvolve Extensions Test ecosystem, designed to provide compatibility between different .NET test frameworks. The main goal is to standardize test categorization across MSTest, NUnit, TUnit, and XUnit frameworks, enabling teams to:
Consistent test categorization across multiple test frameworks
Uniform filtering with commands like dotnet test --filter TestCategory=IntegrationTest
Cross-framework compatibility for test organization and execution
Standardized test classification for different types of testing (Unit, Integration, Performance, etc.)
🚀 Features
Test Category Attributes
UnitTestAttribute - Mark tests as unit tests for isolated component testing
IntegrationTestAttribute - Identify integration tests that test component interactions
AcceptanceTestAttribute - Label acceptance tests for user story validation
- Designate performance and load testing scenarios
PerformanceTestAttribute
EndToEndTestAttribute - Mark comprehensive workflow testing
Compatible with .NET Standard 2.0 projects (.NET Framework 4.6.1+, .NET Core 2.0+)
C# 13 support
TUnit framework compatibility
📖 Usage
All attributes are available in the NetEvolve.Extensions.TUnit namespace.
using NetEvolve.Extensions.TUnit;
Assembly-Level Categorization
Apply categories to all tests in an assembly:
using NetEvolve.Extensions.TUnit;
[assembly: UnitTest] // Mark all test methods in this assembly as UnitTest
Class-Level Categorization
Apply categories to all test methods in a test class:
[TestFixture]
[IntegrationTest] // Mark all test methods in this class as IntegrationTest
public class DatabaseTests
{
[Test]
public void Should_Connect_To_Database()
{
// This test is automatically categorized as IntegrationTest
Assert.That(true, Is.True);
}
[Test]
public void Should_Retrieve_User_Data()
{
// This test is also categorized as IntegrationTest
Assert.That("user", Is.Not.Null);
}
}
Method-Level Categorization
Apply categories to individual test methods:
[TestFixture]
public class CalculatorTests
{
[Test]
[UnitTest] // Individual test method categorization
public void Should_Add_Two_Numbers()
{
var result = Calculator.Add(2, 3);
Assert.That(result, Is.EqualTo(5));
}
[Test]
[PerformanceTest] // Different category for performance testing
public void Should_Handle_Large_Numbers_Quickly()
{
var stopwatch = Stopwatch.StartNew();
Calculator.Add(int.MaxValue, 1000000);
stopwatch.Stop();
Assert.That(stopwatch.ElapsedMilliseconds, Is.LessThan(100));
}
}
Multiple Categories
Apply multiple categories to the same test:
[TestFixture]
public class UserServiceTests
{
[Test]
[IntegrationTest]
[Bug] // Test was added to fix a specific bug
[Issue] // Also tracks a specific issue
public void Should_Handle_Concurrent_User_Updates()
{
// Test implementation for bug fix
Assert.That(true, Is.True);
}
}
Work Item Association
Link tests to specific work items for traceability:
[TestFixture]
public class FeatureTests
{
[Test]
[AcceptanceTest]
[UserStory] // Associates with user story
[Feature] // Links to feature implementation
public void Should_Allow_User_Login()
{
// Test validates user story completion
Assert.That(UserService.Login("user", "password"), Is.True);
}
[Test]
[EndToEndTest]
[Epic] // Associates with epic-level requirement
public void Should_Complete_Order_Workflow()
{
// Comprehensive workflow test
Assert.That(OrderService.ProcessOrder(order), Is.True);
}
}
Deployment Testing
Organize tests for different deployment phases:
[TestFixture]
public class DeploymentTests
{
[Test]
[PreDeploymentTest]
[ArchitectureTest]
public void Should_Validate_System_Architecture()
{
// Validate architectural constraints before deployment
Assert.That(ArchitectureValidator.IsValid(), Is.True);
}
[Test]
[PostDeploymentTest]
[FunctionalTest]
public void Should_Verify_System_Health_After_Deployment()
{
// Verify system health post-deployment
Assert.That(HealthCheck.IsSystemHealthy(), Is.True);
}
}
Flaky Test Handling
Mark tests that are inherently unreliable and should be skipped on failure:
public class FlakyTests
{
[Test]
[SkipOnFailure] // Automatically skips this test if it fails
[IntegrationTest]
public async Task Should_Handle_External_Service_Timeout()
{
// Test that might fail due to external service availability
var service = new ExternalService();
await Assert.That(service.IsAvailable()).IsTrue();
}
[Test]
[SkipOnFailure]
[PerformanceTest]
public async Task Should_Complete_Within_Time_Limit()
{
// Performance test that might be affected by system load
var stopwatch = Stopwatch.StartNew();
PerformHeavyOperation();
stopwatch.Stop();
await Assert.That(stopwatch.ElapsedMilliseconds).IsLessThan(1000);
}
}
You can also apply SkipOnFailure at the class level to mark all tests in the class as flaky:
[SkipOnFailure] // All tests in this class will be skipped on failure
public class ExternalApiTests
{
[Test]
public async Task Should_Fetch_User_Data()
{
// Test implementation
await Assert.That(true).IsTrue();
}
[Test]
public async Task Should_Update_User_Profile()
{
// Test implementation
await Assert.That(true).IsTrue();
}
}
🏗️ Real-World Example
using TUnit.Core;
using NetEvolve.Extensions.TUnit;
using System.Diagnostics;
[assembly: IntegrationTest] // Mark all tests as integration tests by default
namespace MyProject.Tests
{
[TestFixture]
[AcceptanceTest] // Override assembly-level category for this class
public class UserManagementTests
{
[Test]
[UserStory]
[Feature]
public void Should_Create_New_User_Successfully()
{
// Arrange
var userService = new UserService();
var newUser = new User { Name = "John Doe", Email = "john@example.com" };
// Act
var result = userService.CreateUser(newUser);
// Assert
Assert.That(result.Success, Is.True);
Assert.That(result.UserId, Is.Not.Null);
}
[Test]
[Bug] // This test was added to fix a specific bug
[Issue] // Also tracks the issue in work item system
public void Should_Handle_Duplicate_Email_Registration()
{
// Arrange
var userService = new UserService();
var existingUser = new User { Name = "Jane Doe", Email = "jane@example.com" };
userService.CreateUser(existingUser);
// Act
var duplicateUser = new User { Name = "Jane Smith", Email = "jane@example.com" };
var result = userService.CreateUser(duplicateUser);
// Assert
Assert.That(result.Success, Is.False);
Assert.That(result.ErrorMessage, Is.EqualTo("Email already exists"));
}
}
[TestFixture]
public class PerformanceTests
{
[Test]
[PerformanceTest]
[UnitTest] // Can combine categories as needed
public void Should_Process_Large_Dataset_Within_Time_Limit()
{
// Arrange
var processor = new DataProcessor();
var largeDataset = GenerateLargeDataset(10000);
var stopwatch = Stopwatch.StartNew();
// Act
processor.ProcessData(largeDataset);
stopwatch.Stop();
// Assert
Assert.That(stopwatch.ElapsedMilliseconds, Is.LessThan(5000),
"Processing should complete within 5 seconds");
}
private List<DataItem> GenerateLargeDataset(int count) =>
Enumerable.Range(1, count).Select(i => new DataItem { Id = i }).ToList();
}
}
🔧 Test Filtering
Use the attributes with TUnit's filtering capabilities:
# Run only unit tests
dotnet test --filter TestCategory=UnitTest
# Run integration and acceptance tests
dotnet test --filter "TestCategory=IntegrationTest|TestCategory=AcceptanceTest"
# Run all tests except performance tests
dotnet test --filter "TestCategory!=PerformanceTest"
# Run tests associated with bugs
dotnet test --filter TestCategory=Bug
# Run pre-deployment tests only
dotnet test --filter TestCategory=PreDeploymentTest
📚 Available Attributes
Attribute
Purpose
Common Usage
UnitTestAttribute
Individual component testing
Fast, isolated tests
IntegrationTestAttribute
Component interaction testing
Database, API integration
AcceptanceTestAttribute
User story validation
Business requirement verification
PerformanceTestAttribute
Performance validation
Load testing, benchmarks
EndToEndTestAttribute
Complete workflow testing
Full system scenarios
FunctionalTestAttribute
Feature behavior testing
Business logic validation
ArchitectureTestAttribute
Architectural constraint testing
Design rule validation
BugAttribute
Bug fix validation
Regression testing
IssueAttribute
Issue tracking association
Work item linkage
FeatureAttribute
Feature implementation testing
New functionality validation
EpicAttribute
Epic-level requirement testing
High-level feature validation
UserStoryAttribute
User story completion testing
Story acceptance criteria
WorkItemAttribute
Generic work item association
Flexible work tracking
PreDeploymentTestAttribute
Pre-deployment validation
Deployment readiness
PostDeploymentTestAttribute
Post-deployment verification
Production validation
SkipOnFailureAttribute
Flaky test handling
Auto-skip unreliable tests
🤝 Contributing
Contributions are welcome! Please feel free to submit issues, feature requests, or pull requests to the extensions.test repository.
🔗 Related Packages
This package is part of the NetEvolve Extensions Test ecosystem:
