close

Articles Home » Programming Languages » Building a C# Test Framework: Creating Custom Testing Tools

Building a C# Test Framework: Creating Custom Testing Tools

Creating a custom test framework in C# can be an enlightening and rewarding experience. Not only does it enhance your understanding of testing principles, but it also allows you to tailor the framework to meet your specific needs. In this tutorial, we will guide you through the process of building a C# test framework from scratch, focusing on creating custom testing tools.

1. Introduction to Test Frameworks

A test framework provides a structured way to write and execute tests. It typically includes components like test cases, test runners, and assertions. Popular C# test frameworks include NUnit, xUnit, and MSTest. However, building a custom framework can give you greater control and flexibility.

Key Concepts

  • Test Case: A single unit of testing.
  • Test Runner: Executes test cases and collects results.
  • Assertions: Validate test outcomes.

2. Setting Up the Development Environment

Before we start coding, let’s set up our development environment.

Tools Required

  • Visual Studio: An integrated development environment (IDE) for C#.
  • .NET SDK: The software development kit for .NET.

Steps

  1. Install Visual Studio: Download and install Visual Studio.
  2. Install .NET SDK: Download and install the latest .NET SDK.

3. Designing the Test Framework

Designing the test framework involves defining the structure and components. We’ll start with a simple framework and gradually add more features.

Components

  1. Test Case: Represents an individual test.
  2. Test Runner: Manages the execution of tests.
  3. Assertions: Provides methods to verify test results.

4. Implementing the Core Components

Let’s dive into the implementation of the core components.

Test Cases

Create a base class for test cases.

public abstract class TestCase
{
    public abstract void Run();
}Code language: C# (cs)

Test Runner

The test runner will execute all test cases and collect results.

public class TestRunner
{
    private List<TestCase> _testCases = new List<TestCase>();

    public void AddTest(TestCase testCase)
    {
        _testCases.Add(testCase);
    }

    public void RunAllTests()
    {
        foreach (var testCase in _testCases)
        {
            try
            {
                testCase.Run();
                Console.WriteLine($"{testCase.GetType().Name}: Passed");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"{testCase.GetType().Name}: Failed - {ex.Message}");
            }
        }
    }
}Code language: C# (cs)

Assertions

Assertions are used to verify test results.

public static class Assert
{
    public static void IsTrue(bool condition, string message = "Assertion failed")
    {
        if (!condition)
        {
            throw new Exception(message);
        }
    }

    public static void AreEqual(object expected, object actual, string message = "Assertion failed")
    {
        if (!expected.Equals(actual))
        {
            throw new Exception($"{message}: Expected {expected}, but got {actual}");
        }
    }
}Code language: C# (cs)

Example Test Case

Let’s create an example test case.

public class SampleTest : TestCase
{
    public override void Run()
    {
        Assert.IsTrue(1 + 1 == 2, "Math is broken");
        Assert.AreEqual("Hello", "Hello", "Strings are not equal");
    }
}Code language: C# (cs)

Running the Tests

Finally, create a main method to run the tests.

class Program
{
    static void Main(string[] args)
    {
        TestRunner runner = new TestRunner();
        runner.AddTest(new SampleTest());
        runner.RunAllTests();
    }
}Code language: C# (cs)

5. Enhancing the Framework

Now that we have a basic framework, let’s enhance it with more features.

Test Suites

A test suite groups multiple test cases.

public class TestSuite
{
    private List<TestCase> _testCases = new List<TestCase>();

    public void AddTest(TestCase testCase)
    {
        _testCases.Add(testCase);
    }

    public void Run()
    {
        foreach (var testCase in _testCases)
        {
            try
            {
                testCase.Run();
                Console.WriteLine($"{testCase.GetType().Name}: Passed");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"{testCase.GetType().Name}: Failed - {ex.Message}");
            }
        }
    }
}Code language: C# (cs)

Reporting

Generate a report of test results.

public class TestReporter
{
    private List<string> _results = new List<string>();

    public void AddResult(string result)
    {
        _results.Add(result);
    }

    public void GenerateReport()
    {
        foreach (var result in _results)
        {
            Console.WriteLine(result);
        }
    }
}Code language: C# (cs)

Logging

Add logging capabilities to track test execution.

public static class Logger
{
    public static void Log(string message)
    {
        Console.WriteLine($"LOG: {message}");
    }
}Code language: C# (cs)

Example Enhanced Test Runner

Here’s how you can integrate these enhancements.

public class EnhancedTestRunner
{
    private List<TestCase> _testCases = new List<TestCase>();
    private TestReporter _reporter = new TestReporter();

    public void AddTest(TestCase testCase)
    {
        _testCases.Add(testCase);
    }

    public void RunAllTests()
    {
        foreach (var testCase in _testCases)
        {
            try
            {
                testCase.Run();
                _reporter.AddResult($"{testCase.GetType().Name}: Passed");
            }
            catch (Exception ex)
            {
                _reporter.AddResult($"{testCase.GetType().Name}: Failed - {ex.Message}");
            }
        }
        _reporter.GenerateReport();
    }
}Code language: C# (cs)

6. Advanced Features

Parameterized Tests

Allow tests to be run with different inputs.

public abstract class ParameterizedTestCase : TestCase
{
    public abstract void Run(params object[] parameters);
}Code language: C# (cs)

Mocking

Mocking is useful for isolating test cases by simulating dependencies.

public class MockService
{
    public virtual string GetData()
    {
        return "Real data";
    }
}

public class MockServiceTest : TestCase
{
    public override void Run()
    {
        var mockService = new MockService();
        Assert.AreEqual("Real data", mockService.GetData(), "Mock service failed");
    }
}Code language: C# (cs)

Integration with CI/CD

Integrate your test framework with continuous integration/continuous deployment (CI/CD) pipelines to automate testing.

Example GitHub Actions Workflow

name: .NET Test

on: [push, pull_request]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v2
    - name: Setup .NET
      uses: actions/setup-dotnet@v1
      with:
        dotnet-version: '5.0.x'
    - name: Restore dependencies
      run: dotnet restore
    - name: Build
      run: dotnet build --no-restore
    - name: Test
      run: dotnet test --no-buildCode language: YAML (yaml)

Conclusion

Building a custom test framework in C# allows you to create a testing environment tailored to your needs. We’ve covered the basics of setting up the development environment, designing the framework, implementing core components, and adding advanced features. This tutorial serves as a foundation, and you can further extend the framework with additional functionalities as required.

By following this tutorial, you should have a solid understanding of the principles and practices involved in creating a custom test framework in C#.

Related posts: