Get the FREE Ultimate OpenClaw Setup Guide →

csharp-nunit

Scanned
npx machina-cli add skill github/awesome-copilot/csharp-nunit --openclaw
Files (1)
SKILL.md
2.8 KB

NUnit Best Practices

Your goal is to help me write effective unit tests with NUnit, covering both standard and data-driven testing approaches.

Project Setup

  • Use a separate test project with naming convention [ProjectName].Tests
  • Reference Microsoft.NET.Test.Sdk, NUnit, and NUnit3TestAdapter packages
  • Create test classes that match the classes being tested (e.g., CalculatorTests for Calculator)
  • Use .NET SDK test commands: dotnet test for running tests

Test Structure

  • Apply [TestFixture] attribute to test classes
  • Use [Test] attribute for test methods
  • Follow the Arrange-Act-Assert (AAA) pattern
  • Name tests using the pattern MethodName_Scenario_ExpectedBehavior
  • Use [SetUp] and [TearDown] for per-test setup and teardown
  • Use [OneTimeSetUp] and [OneTimeTearDown] for per-class setup and teardown
  • Use [SetUpFixture] for assembly-level setup and teardown

Standard Tests

  • Keep tests focused on a single behavior
  • Avoid testing multiple behaviors in one test method
  • Use clear assertions that express intent
  • Include only the assertions needed to verify the test case
  • Make tests independent and idempotent (can run in any order)
  • Avoid test interdependencies

Data-Driven Tests

  • Use [TestCase] for inline test data
  • Use [TestCaseSource] for programmatically generated test data
  • Use [Values] for simple parameter combinations
  • Use [ValueSource] for property or method-based data sources
  • Use [Random] for random numeric test values
  • Use [Range] for sequential numeric test values
  • Use [Combinatorial] or [Pairwise] for combining multiple parameters

Assertions

  • Use Assert.That with constraint model (preferred NUnit style)
  • Use constraints like Is.EqualTo, Is.SameAs, Contains.Item
  • Use Assert.AreEqual for simple value equality (classic style)
  • Use CollectionAssert for collection comparisons
  • Use StringAssert for string-specific assertions
  • Use Assert.Throws<T> or Assert.ThrowsAsync<T> to test exceptions
  • Use descriptive messages in assertions for clarity on failure

Mocking and Isolation

  • Consider using Moq or NSubstitute alongside NUnit
  • Mock dependencies to isolate units under test
  • Use interfaces to facilitate mocking
  • Consider using a DI container for complex test setups

Test Organization

  • Group tests by feature or component
  • Use categories with [Category("CategoryName")]
  • Use [Order] to control test execution order when necessary
  • Use [Author("DeveloperName")] to indicate ownership
  • Use [Description] to provide additional test information
  • Consider [Explicit] for tests that shouldn't run automatically
  • Use [Ignore("Reason")] to temporarily skip tests

Source

git clone https://github.com/github/awesome-copilot/blob/main/plugins/csharp-dotnet-development/skills/csharp-nunit/SKILL.mdView on GitHub

Overview

Learn NUnit best practices for writing effective unit tests, including data-driven approaches. This guide covers project setup, test structure, standard and data-driven test patterns, assertions, mocking, and organization to keep tests reliable and maintainable.

How This Skill Works

Create a dedicated test project named [ProjectName].Tests and reference Microsoft.NET.Test.Sdk, NUnit, and NUnit3TestAdapter. Write tests using [TestFixture] and [Test], following the Arrange-Act-Assert pattern, and name tests as MethodName_Scenario_ExpectedBehavior; use data-driven attributes like [TestCase] and [TestCaseSource] to cover multiple inputs.

When to Use It

  • When validating a class with a dedicated test class like CalculatorTests.
  • When you need data-driven coverage across multiple inputs using attributes like [TestCase] or [TestCaseSource].
  • When organizing tests by feature or component for maintainability and clarity.
  • When you require per-test ([SetUp]/[TearDown]) and per-class ([OneTimeSetUp]/[OneTimeTearDown]) hooks.
  • When you want to isolate dependencies with mocks (e.g., Moq or NSubstitute) to test units.

Quick Start

  1. Step 1: Create a separate test project named [ProjectName].Tests and add Microsoft.NET.Test.Sdk, NUnit, and NUnit3TestAdapter.
  2. Step 2: Write tests with [TestFixture] on classes and [Test] on methods, following AAA and the MethodName_Scenario_ExpectedBehavior naming pattern.
  3. Step 3: Add data-driven tests using [TestCase], [TestCaseSource], [Values], [ValueSource], [Random], [Range], or [Combinatorial]/[Pairwise], then run tests with 'dotnet test'.

Best Practices

  • Keep tests focused on a single behavior; avoid multiple behaviors per test.
  • Name tests using the pattern MethodName_Scenario_ExpectedBehavior for clarity.
  • Follow Arrange-Act-Assert (AAA) in every test to improve readability.
  • Use data-driven attributes ([TestCase], [TestCaseSource], [Values], [ValueSource], [Random], [Range], [Combinatorial]/[Pairwise]).
  • Mock dependencies to isolate the unit under test and use descriptive assertion messages.

Example Use Cases

  • Test Calculator.Add with inputs 2 and 3 to verify 5 using a [TestCase].
  • Data-driven pricing rule tests for multiple scenarios using [TestCaseSource].
  • Test class CalculatorTests with [TestFixture] and [Test] following AAA.
  • Use [SetUpFixture] to initialize shared resources for all tests in the assembly.
  • Assert.ThrowsAsync<InvalidOperationException> for an error path in an async method.

Frequently Asked Questions

Add this skill to your agents
Sponsor this space

Reach thousands of developers