C#でのユニットテストの書き方とおすすめツール

using Microsoft.VisualStudio.TestTools.UnitTesting;

[TestClass]
public class CalculatorTests
{
    [TestMethod]
    public void Add_ShouldReturnSum_WhenGivenTwoNumbers()
    {
        // Arrange
        var calculator = new Calculator();
        int a = 5;
        int b = 3;

        // Act
        var result = calculator.Add(a, b);

        // Assert
        Assert.AreEqual(8, result);
    }
}

Install-Package NUnit
Install-Package NUnit3TestAdapter

using NUnit.Framework;

[TestFixture]
public class CalculatorTests
{
    [Test]
    public void Add_ShouldReturnSum_WhenGivenTwoNumbers()
    {
        // Arrange
        var calculator = new Calculator();
        int a = 5;
        int b = 3;

        // Act
        var result = calculator.Add(a, b);

        // Assert
        Assert.AreEqual(8, result);
    }
}

[TestCase(2, 3, 5)]
[TestCase(-2, -3, -5)]
public void Add_ShouldReturnCorrectSum(int a, int b, int expected)
{
    var calculator = new Calculator();
    var result = calculator.Add(a, b);
    Assert.AreEqual(expected, result);
}

Install-Package MSTest.TestFramework
Install-Package MSTest.TestAdapter

using Microsoft.VisualStudio.TestTools.UnitTesting;

[TestClass]
public class CalculatorTests
{
    [TestMethod]
    public void Add_ShouldReturnSum_WhenGivenTwoNumbers()
    {
        // Arrange
        var calculator = new Calculator();
        int a = 5;
        int b = 3;

        // Act
        var result = calculator.Add(a, b);

        // Assert
        Assert.AreEqual(8, result);
    }
}

[TestInitialize]
public void Setup()
{
    // 各テストの前に実行されるセットアップコード
}

[TestCleanup]
public void Cleanup()
{
    // 各テストの後に実行されるクリーンアップコード
}

[DataTestMethod]
[DataRow(2, 3, 5)]
[DataRow(-2, -3, -5)]
public void Add_ShouldReturnCorrectSum(int a, int b, int expected)
{
    var calculator = new Calculator();
    var result = calculator.Add(a, b);
    Assert.AreEqual(expected, result);
}

Install-Package xunit
Install-Package xunit.runner.visualstudio

using Xunit;

public class CalculatorTests
{
    [Fact]
    public void Add_ShouldReturnSum_WhenGivenTwoNumbers()
    {
        // Arrange
        var calculator = new Calculator();
        int a = 5;
        int b = 3;

        // Act
        var result = calculator.Add(a, b);

        // Assert
        Assert.Equal(8, result);
    }
}

public class CalculatorTests : IDisposable
{
    private readonly Calculator _calculator;

    public CalculatorTests()
    {
        // 各テストの前に実行されるセットアップコード
        _calculator = new Calculator();
    }

    [Fact]
    public void Add_ShouldReturnSum_WhenGivenTwoNumbers()
    {
        int a = 5;
        int b = 3;
        var result = _calculator.Add(a, b);
        Assert.Equal(8, result);
    }

    public void Dispose()
    {
        // 各テストの後に実行されるクリーンアップコード
    }
}

[Theory]
[InlineData(2, 3, 5)]
[InlineData(-2, -3, -5)]
public void Add_ShouldReturnCorrectSum(int a, int b, int expected)
{
    var calculator = new Calculator();
    var result = calculator.Add(a, b);
    Assert.Equal(expected, result);
}

Install-Package Moq

using Moq;
using Xunit;

public class CalculatorServiceTests
{
    [Fact]
    public void Add_ShouldReturnSum_WhenGivenTwoNumbers()
    {
        // Arrange
        var mockCalculator = new Mock<ICalculator>();
        mockCalculator.Setup(m => m.Add(It.IsAny<int>(), It.IsAny<int>())).Returns(8);
        var calculatorService = new CalculatorService(mockCalculator.Object);

        // Act
        var result = calculatorService.Add(5, 3);

        // Assert
        Assert.Equal(8, result);
    }
}

Install-Package FakeItEasy

using FakeItEasy;
using Xunit;

public class CalculatorServiceTests
{
    [Fact]
    public void Add_ShouldReturnSum_WhenGivenTwoNumbers()
    {
        // Arrange
        var fakeCalculator = A.Fake<ICalculator>();
        A.CallTo(() => fakeCalculator.Add(A<int>.Ignored, A<int>.Ignored)).Returns(8);
        var calculatorService = new CalculatorService(fakeCalculator);

        // Act
        var result = calculatorService.Add(5, 3);

        // Assert
        Assert.Equal(8, result);
    }
}

name: .NET Core

on:
  push:
    branches:
      - main
  pull_request:
    branches:
      - main

jobs:
  build:

    runs-on: ubuntu-latest

    steps:
    - name: チェックアウトリポジトリ
      uses: actions/checkout@v2

    - name: .NET Coreセットアップ
      uses: actions/setup-dotnet@v1
      with:
        dotnet-version: '5.0.x'

    - name: 依存関係の復元
      run: dotnet restore

    - name: ビルド
      run: dotnet build --no-restore

    - name: テストの実行
      run: dotnet test --no-build --verbosity normal

trigger:
- main

pool:
  vmImage: 'ubuntu-latest'

steps:
- task: UseDotNet@2
  inputs:
    packageType: 'sdk'
    version: '5.x'
    installationPath: $(Agent.ToolsDirectory)/dotnet

- script: dotnet restore
  displayName: '依存関係の復元'

- script: dotnet build --no-restore
  displayName: 'ビルド'

- script: dotnet test --no-build --verbosity normal
  displayName: 'テストの実行'

[Test]
public void Add_ShouldReturnSum_WhenGivenTwoNumbers()
{
    // Arrange
    var calculator = new Calculator();
    int a = 5;
    int b = 3;

    // Act
    var result = calculator.Add(a, b);

    // Assert
    Assert.AreEqual(8, result);
}

var mockCalculator = new Mock<ICalculator>();
mockCalculator.Setup(m => m.Add(It.IsAny<int>(), It.IsAny<int>())).Returns(8);

public class TaxCalculator
{
    public decimal CalculateTax(decimal amount, decimal taxRate)
    {
        if (amount < 0 || taxRate < 0)
        {
            throw new ArgumentException("Amount and tax rate must be non-negative");
        }
        return amount * taxRate;
    }
}

[TestClass]
public class TaxCalculatorTests
{
    [TestMethod]
    public void CalculateTax_ShouldReturnCorrectTax_WhenValidInputs()
    {
        // Arrange
        var taxCalculator = new TaxCalculator();
        decimal amount = 100m;
        decimal taxRate = 0.15m;

        // Act
        var result = taxCalculator.CalculateTax(amount, taxRate);

        // Assert
        Assert.AreEqual(15m, result);
    }

    [TestMethod]
    [ExpectedException(typeof(ArgumentException))]
    public void CalculateTax_ShouldThrowException_WhenNegativeAmount()
    {
        // Arrange
        var taxCalculator = new TaxCalculator();
        decimal amount = -100m;
        decimal taxRate = 0.15m;

        // Act
        taxCalculator.CalculateTax(amount, taxRate);

        // Assert: handled by ExpectedException
    }
}

public interface IUserRepository
{
    User GetUserById(int id);
}

public class UserService
{
    private readonly IUserRepository _userRepository;

    public UserService(IUserRepository userRepository)
    {
        _userRepository = userRepository;
    }

    public User GetUser(int id)
    {
        return _userRepository.GetUserById(id);
    }
}

[TestClass]
public class UserServiceTests
{
    [TestMethod]
    public void GetUser_ShouldReturnUser_WhenUserExists()
    {
        // Arrange
        var mockRepository = new Mock<IUserRepository>();
        var user = new User { Id = 1, Name = "John Doe" };
        mockRepository.Setup(repo => repo.GetUserById(1)).Returns(user);
        var userService = new UserService(mockRepository.Object);

        // Act
        var result = userService.GetUser(1);

        // Assert
        Assert.AreEqual(user, result);
    }
}

public class StringManipulator
{
    public string ReverseString(string input)
    {
        if (input == null)
        {
            throw new ArgumentNullException(nameof(input));
        }
        return new string(input.Reverse().ToArray());
    }
}

public interface IWeatherApiClient
{
    WeatherInfo GetWeather(string location);
}

public class WeatherService
{
    private readonly IWeatherApiClient _weatherApiClient;

    public WeatherService(IWeatherApiClient weatherApiClient)
    {
        _weatherApiClient = weatherApiClient;
    }

    public WeatherInfo GetWeatherForLocation(string location)
    {
        return _weatherApiClient.GetWeather(location);
    }
}