Skip to main content
Agent skill

Csharp Testing

C# and .NET testing patterns with xUnit, FluentAssertions, mocking, integration tests, and test organization best practices. Use when writing or reviewing xUnit tests, mocks, or integration tests in a C# / .NET project.

Get started

Get the complete skill folder, including its scripts and reference files.

·

When to use this skill

Use Csharp Testing when an AI agent needs a reusable SKILL.md workflow for this job: C# and .NET testing patterns with xUnit, FluentAssertions, mocking, integration tests, and test organization best practices. Use when writing or reviewing xUnit tests, mocks, or integration tests in a C# / .NET project.

When not to use it

Skip Csharp Testing when the task is outside the coding category, or when a more specific skill in this directory already covers the same workflow with clearer triggers.

How to install

Where will you use it?

Install scope
Claude Code folder setup
mkdir -p ~/.claude/skills/csharp-testing
# Save SKILL.md to ~/.claude/skills/csharp-testing/SKILL.md
  1. Claude Code personal install: place the skill and its bundled files at ~/.claude/skills/csharp-testing/SKILL.md. For a shared project, commit the folder at .claude/skills/csharp-testing/ instead.
  2. Current Claude Code detects SKILL.md changes in watched directories during the session. If you just created a top-level skills directory, run /reload-skills. Check that the skill is listed before testing its trigger.
  3. For Claude chat or Cowork in the Desktop app, manage uploaded skills in Customize > Skills; copying files into a local Claude Code folder is not a Desktop install. Other agents may use different install locations.

Full install guide for Claude, Cursor, and Codex →

Try a starter prompt

After installing the skill, paste this starter prompt into your agent to verify it triggers on a small task.

Starter prompt
Use the Csharp Testing skill for this task: Use Csharp Testing when this documented workflow matches the task. Confirm any required inputs or files before making changes.

What supports this recommendation?

71/100 provisional content score. This measures documentation, practical detail and source signals. It is not a measured task success rate or a security certification.

Documentation
77/100
Practical detail
68/100
Source evidence
63/100
Source signals
72/100
Model compatibility evidence
  • claudeuntested

    No model-specific signal or recorded compatibility test was found.

  • chatgptuntested

    No model-specific signal or recorded compatibility test was found.

  • geminiuntested

    No model-specific signal or recorded compatibility test was found.

  • copilotuntested

    No model-specific signal or recorded compatibility test was found.

  • llamauntested

    No model-specific signal or recorded compatibility test was found.

  • perplexityuntested

    No model-specific signal or recorded compatibility test was found.

  • mistraluntested

    No model-specific signal or recorded compatibility test was found.

  • grokuntested

    No model-specific signal or recorded compatibility test was found.

Inferred compatibility is based on content signals. Check the app, its available tools and setup requirements before running a skill.

What this skill does

# C# Testing Patterns

Comprehensive testing patterns for .NET applications using xUnit, FluentAssertions, and modern testing practices.

## When to Activate

- Writing new tests for C# code - Reviewing test quality and coverage - Setting up test infrastructure for .NET projects - Debugging flaky or slow tests

## Test Framework Stack

| Tool | Purpose | |---|---| | **xUnit** | Test framework (preferred for .NET) | | **FluentAssertions** | Readable assertion syntax | | **NSubstitute** or **Moq** | Mocking dependencies | | **Testcontainers** | Real infrastructure in integration tests | | **WebApplicationFactory** | ASP.NET Core integration tests | | **Bogus** | Realistic test data generation |

## Unit Test Structure

### Arrange-Act-Assert

```csharp public sealed class OrderServiceTests { private readonly IOrderRepository _repository = Substitute.For<IOrderRepository>(); private readonly ILogger<OrderService> _logger = Substitute.For<ILogger<OrderService>>(); private readonly OrderService _sut;

public OrderServiceTests() { _sut = new OrderService(_repository, _logger); }

[Fact] public async Task PlaceOrderAsync_ReturnsSuccess_WhenRequestIsValid() { // Arrange var request = new CreateOrderRequest { CustomerId = "cust-123", Items = [new OrderItem("SKU-001", 2, 29.99m)] };

// Act var result = await _sut.PlaceOrderAsync(request, CancellationToken.None);

// Assert result.IsSuccess.Should().BeTrue(); result.Value.Should().NotBeNull(); result.Value!.CustomerId.Should().Be("cust-123"); }

[Fact] public async Task PlaceOrderAsync_ReturnsFailure_WhenNoItems() { // Arrange var request = new CreateOrderRequest { CustomerId = "cust-123", Items = [] };

// Act var result = await _sut.PlaceOrderAsync(request, CancellationToken.None);

// Assert result.IsSuccess.Should().BeFalse(); result.Error.Should().Contain("at least one item"); } } ```

### Parameterized Tests with Theory

```csharp [Theory] [InlineData("", false)] [InlineData("a", false)] [InlineData("[email protected]", false)] [InlineData("[email protected]", true)] [InlineData("[email protected]", true)] public void IsValidEmail_ReturnsExpected(string email, bool expected) { EmailValidator.IsValid(email).Should().Be(expected); }

[Theory] [MemberData(nameof(InvalidOrderCases))] public async Task PlaceOrderAsync_RejectsInvalidOrders(CreateOrderRequest request, string expectedError) { var result = await _sut.PlaceOrderAsync(request, CancellationToken.None);

result.IsSuccess.Should().BeFalse(); result.Error.Should().Contain(expectedError); }

public static TheoryData<CreateOrderRequest, string> InvalidOrderCases => new() { { new() { CustomerId = "", Items = [ValidItem()] }, "CustomerId" }, { new() { CustomerId = "c1", Items = [] }, "at least one item" }, { new() { CustomerId = "c1", Items = [new("", 1, 10m)] }, "SKU" }, }; ```

## Mocking with NSubstitute

```csharp [Fact] public async Task GetOrderAsync_ReturnsNull_WhenNotFound() { // Arrange var orderId = Guid.NewGuid(); _repository.FindByIdAsync(orderId, Arg.Any<CancellationToken>()) .Returns((Order?)null);

// Act var result = await _sut.GetOrderAsync(orderId, CancellationToken.None);

// Assert result.Should().BeNull(); }

[Fact] public async Task PlaceOrderAsync_PersistsOrder() { // Arrange var request = ValidOrderRequest();

// Act await _sut.PlaceOrderAsync(request, CancellationToken.None);

// Assert — verify the repository was called await _repository.Received(1).AddAsync( Arg.Is<Order>(o => o.CustomerId == request.CustomerId), Arg.Any<CancellationToken>()); } ```

## ASP.NET Core Integration Tests

### WebApplicationFactory Setup

```csharp public sealed class OrderApiTests : IClassFixture<WebApplicationFactory<Program>> { private readonly HttpClient _client;

public OrderApiTests(WebApplicationFactory<Program> factory) { _client = factory.WithWebHostBuilder(builder => { builder.ConfigureServices(services => { // Replace real DB with in-memory for tests services.RemoveAll<DbContextOptions<AppDbContext>>(); services.AddDbContext<AppDbContext>(options => options.UseInMemoryDatabase("TestDb")); }); }).CreateClient(); }

[Fact] public async Task GetOrder_Returns404_WhenNotFound() { var response = await _client.GetAsync($"/api/orders/{Guid.NewGuid()}");

response.StatusCode.Should().Be(HttpStatusCode.NotFound); }

[Fact] public async Task CreateOrder_Returns201_WithValidRequest() { var request = new CreateOrderRequest { CustomerId = "cust-1", Items = [new("SKU-001", 1, 19.99m)] };

var response = await _client.PostAsJsonAsync("/api/orders", request);

response.StatusCode.Should().Be(HttpStatusCode.Created); response.Headers.Location.Should().NotBeNull(); } } ```

### Testing with Testcontainers

```csharp public sealed class PostgresOrderRepositoryTests : IAsyncLifetime { private readonly PostgreSqlContainer _postgres = new PostgreSqlBuilder() .WithImage("postgres:16-alpine") .Build();

private AppDbContext _db = null!;

public async Task InitializeAsync() { await _postgres.StartAsync(); var options = new DbContextOptionsBuilder<AppDbContext>() .UseNpgsql(_postgres.GetConnectionString()) .Options; _db = new AppDbContext(options); await _db.Database.MigrateAsync(); }

public async Task DisposeAsync() { await _db.DisposeAsync(); await _postgres.DisposeAsync(); }

[Fact] public async Task AddAsync_PersistsOrder() { var repo = new SqlOrderRepository(_db); var order = Order.Create("cust-1", [new OrderItem("SKU-001", 2, 10m)]);

await repo.AddAsync(order, CancellationToken.None);

var found = await repo.FindByIdAsync(order.Id, CancellationToken.None); found.Should().NotBeNull(); found!.Items.Should().HaveCount(1); } } ```

## Test Organization

``` tests/ MyApp.UnitTests/ Services/ OrderServiceTests.cs PaymentServiceTests.cs Validators/ EmailValidatorTests.cs MyApp.IntegrationTests/ Api/ OrderApiTests.cs Repositories/ OrderRepositoryTests.cs MyApp.TestHelpers/ Builders/ OrderBuilder.cs Fixtures/ DatabaseFixture.cs ```

## Test Data Builders

```csharp public sealed class OrderBuilder { private string _customerId = "cust-default"; private readonly List<OrderItem> _items = [new("SKU-001", 1, 10m)];

public OrderBuilder WithCustomer(string customerId) { _customerId = customerId; return this; }

public OrderBuilder WithItem(string sku, int quantity, decimal price) { _items.Add(new OrderItem(sku, quantity, price)); return this; }

public Order Build() => Order.Create(_customerId, _items); }

// Usage in tests var order = new OrderBuilder() .WithCustomer("cust-vip") .WithItem("SKU-PREMIUM", 3, 99.99m) .Build(); ```

## Common Anti-Patterns

| Anti-Pattern | Fix | |---|---| | Testing implementation details | Test behavior and outcomes | | Shared mutable test state | Fresh instance per test (xUnit does this via constructors) | | `Thread.Sleep` in async tests | Use `Task.Delay` with timeout, or polling helpers | | Asserting on `ToString()` output | Assert on typed properties | | One giant assertion per test | One logical assertion per test | | Test names describing implementation | Name by behavior: `Method_ExpectedResult_WhenCondition` | | Ignoring `CancellationToken` | Always pass and verify cancellation |

## Running Tests

```bash # Run all tests dotnet test

# Run with coverage dotnet test --collect:"XPlat Code Coverage"

# Run specific project dotnet test tests/MyApp.UnitTests/

# Filter by test name dotnet test --filter "FullyQualifiedName~OrderService"

# Watch mode during development dotnet watch test --project tests/MyApp.UnitTests/ ```

Intended uses

  • Use Csharp Testing when this documented workflow matches the task.

Implementation notes

  • Review the source instructions and adapt inputs before running the workflow.

Try it, then tell us how it went

A copied prompt does not tell us whether the task worked. Report your result after checking the output. We collect your tool and outcome, never your files or prompt.