C# Unit Test Rehberi: xUnit ile Başlangıçtan Uzmanlığa

Modern yazılım geliştirmede unit testing, kodun güvenilirliğini sağlayan en kritik pratiklerden biridir. C# ekosisteminde xUnit, geliştiricilerin %85’inin tercih ettiği unit testing framework’ü olarak öne çıkmaktadır. Günümüzde büyük yazılım projelerinde bug’ların %60’ı production’a çıkmadan unit testler sayesinde yakalanmaktadır. xUnitTest yaklaşımı, hem bireysel geliştiriciler hem de enterprise düzeydeki projeler için vazgeçilmez bir araç haline gelmiştir.

Bu rehberde, C# unit test dünyasına kapsamlı bir giriş yapacak, xUnit framework’ünün inceliklerini keşfedecek ve profesyonel kod kalitesi elde etmek için gereken tüm teknikleri öğreneceksiniz. Başlangıç seviyesinden uzman seviyesine kadar her geliştiricinin ihtiyaç duyacağı bilgiler, pratik örnekler ve best practice’ler ile desteklenmiştir.

Unit Testing’in Temelleri ve C# Ekosistemindeki Yeri

Unit Testing Nedir?

Unit testing, yazılım geliştirmede en küçük test edilebilir parçaların (genellikle method’lar) izole bir şekilde test edilmesi sürecidir. C# dünyasında unit test, bir method’un beklenen davranışı sergileyip sergilemediğini doğrulayan otomatik testler yazmak anlamına gelir.

Unit testlerin temel faydaları şunlardır:

• Erken bug tespiti: Kodun production’a çıkmadan önce hatalarının yakalanması
• Güvenli refactoring: Kod yapısını değiştirirken mevcut işlevselliğin korunması
• Canlı dokümantasyon: Testler kodun nasıl kullanılacağını gösteren örnekler sunar
• Daha temiz kod: Test edilebilir kod yazmak, daha modüler ve loosely coupled tasarım gerektirir

xUnit Framework’ünün Avantajları

xUnit, .NET Core ve .NET 5+ projelerinde varsayılan olarak gelen ve Microsoft tarafından önerilen unit testing framework’üdür. NUnit ve MSTest gibi alternatiflere kıyasla öne çıkan özellikleri:

• Modern tasarım: Lambda expressions ve LINQ desteği
• Dependency injection desteği
• Paralel test execution imkanı
• Extensible architecture ile özelleştirilebilirlik

Test Framework’leri Karşılaştırması

xUnit ile İlk Adımlar: Kurulum ve Temel Yapı

Proje Kurulumu

xUnit ile test projesi oluşturmak için öncelikle gerekli NuGet paketlerinin yüklenmesi gerekir. Temel kurulum için üç paket gereklidir:

// Package Manager Console'da çalıştırılacak komutlar
Install-Package xunit
Install-Package xunit.runner.visualstudio  
Install-Package Microsoft.NET.Test.Sdk

Alternatif olarak, .NET CLI kullanarak doğrudan xUnit projesi oluşturabilirsiniz

dotnet new xunit -o MyUnitTests
cd MyUnitTests
dotnet restore

İlk Test Yazımı

xUnit’te iki temel test türü bulunur: Fact ve Theory. İşte basit bir örnek:

using Xunit;

namespace MyUnitTests
{
    public class CalculatorTests
    {
        [Fact]
        public void Add_TwoPositiveNumbers_ReturnsCorrectSum()
        {
            // Arrange
            var calculator = new Calculator();
            int a = 5;
            int b = 3;
            int expected = 8;

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

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

Bu örnekte görüldüğü gibi, [Fact] attribute’u sabit test senaryoları için kullanılır. Test method’unun adı, test edilen method, koşul ve beklenen sonucu açıkça belirtir.

AAA Pattern: Arrange-Act-Assert Metodolojisi

AAA Pattern’in Önemi

Arrange-Act-Assert (AAA) pattern’i, unit testlerin yapılandırılması için evrensel olarak kabul görmüş bir yaklaşımdır. Bu pattern, testlerin okunabilirliğini ve sürdürülebilirliğini önemli ölçüde artırır.

AAA Pattern’in Üç Aşaması

Arrange (Hazırlık): Test için gerekli nesnelerin oluşturulması ve ön koşulların hazırlanması
Act (Eylem): Test edilecek method’un çağrılması ve sonucun alınması
Assert (Doğrulama): Sonucun beklenen değerle karşılaştırılması

[Fact]
public void GetFullName_ValidUser_ReturnsCorrectFormat()
{
    // Arrange
    var user = new User("John", "Doe");
    var expected = "John Doe";
    
    // Act
    var result = user.GetFullName();
    
    // Assert
    Assert.Equal(expected, result);
}

[Fact]
public void Divide_ByZero_ThrowsArgumentException()
{
    // Arrange
    var calculator = new Calculator();
    
    // Act & Assert
    Assert.Throws<ArgumentException>(() => calculator.Divide(10, 0));
}

Theory ve Parameterized Testing

Theory Attribute’unun Gücü

[Theory] attribute’u, aynı test mantığını farklı veri setleriyle çalıştırmak için kullanılır. Bu yaklaşım, kod tekrarını azaltır ve test kapsamını genişletir.

InlineData ile Basit Parametreler

En yaygın kullanım şekli InlineData attribute’udur:

[Theory]
[InlineData(2, 3, 5)]
[InlineData(-2, -3, -5)]
[InlineData(0, 0, 0)]
[InlineData(1000, 500, 1500)]
public void Add_DifferentNumbers_ReturnsCorrectSum(int a, int b, int expected)
{
    // Arrange
    var calculator = new Calculator();
    
    // Act
    var result = calculator.Add(a, b);
    
    // Assert
    Assert.Equal(expected, result);
}

MemberData ile Kompleks Veri Yapıları

Karmaşık veri yapıları için MemberData attribute’u kullanılır:

public static IEnumerable<object[]> GetTestData()
{
    return new List<object[]>
    {
        new object[] { new User("John", "Doe"), "John Doe" },
        new object[] { new User("Jane", "Smith"), "Jane Smith" },
        new object[] { new User("", ""), " " }
    };
}

[Theory]
[MemberData(nameof(GetTestData))]
public void GetFullName_VariousUsers_ReturnsExpectedFormat(User user, string expected)
{
    // Act
    var result = user.GetFullName();
    
    // Assert
    Assert.Equal(expected, result);
}

ClassData ile Organize Veri Yönetimi

Büyük veri setleri için ClassData approach’u tercih edilir:

public class UserTestData : IEnumerable<object[]>
{
    public IEnumerator<object[]> GetEnumerator()
    {
        yield return new object[] { new User("John", "Doe"), "John Doe" };
        yield return new object[] { new User("Jane", "Smith"), "Jane Smith" };
    }

    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}

[Theory]
[ClassData(typeof(UserTestData))]
public void GetFullName_ClassData_ReturnsExpectedFormat(User user, string expected)
{
    var result = user.GetFullName();
    Assert.Equal(expected, result);
}

Mocking ve Dependency Management

Moq Framework’ü ile Mock Nesneler

Gerçek dünya uygulamalarında, test edilen class’lar genellikle external dependencies’e sahiptir. Moq framework’ü, bu dependencies’leri mock etmek için güçlü bir araç sunar.

public interface IEmailService
{
    bool SendEmail(string to, string subject, string body);
}

public class UserService
{
    private readonly IEmailService _emailService;
    
    public UserService(IEmailService emailService)
    {
        _emailService = emailService;
    }
    
    public bool RegisterUser(User user)
    {
        // Registration logic
        return _emailService.SendEmail(user.Email, "Welcome", "Welcome message");
    }
}

Mock Setup ve Verification

[Fact]
public void RegisterUser_ValidUser_SendsWelcomeEmail()
{
    // Arrange
    var mockEmailService = new Mock<IEmailService>();
    mockEmailService.Setup(x => x.SendEmail(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()))
                   .Returns(true);
    
    var userService = new UserService(mockEmailService.Object);
    var user = new User { Email = "test@example.com" };
    
    // Act
    var result = userService.RegisterUser(user);
    
    // Assert
    Assert.True(result);
    mockEmailService.Verify(x => x.SendEmail("test@example.com", "Welcome", "Welcome message"), 
                           Times.Once);
}

// İyi örnekler
[Fact] public void Add_TwoPositiveNumbers_ReturnsSum() { }
[Fact] public void GetUser_NonExistentId_ThrowsNotFoundException() { }
[Fact] public void ValidateEmail_InvalidFormat_ReturnsFalse() { }

// Kötü örnekler  
[Fact] public void TestAdd() { }
[Fact] public void Test1() { }

FIRST Principles

Unit testler FIRST prensiplerine uymalıdır:

• Fast: Testler hızlı çalışmalı (saniyeler içinde)

• Isolated: Testler birbirinden bağımsız olmalı

• Repeatable: Her çalışmada aynı sonucu vermeli

• Self-validating: Pass/Fail durumu açık olmalı

• Timely: Kod yazılırken veya hemen sonrasında yazılmalı

Kaçınılması Gereken Hatalar

Magic Numbers ve Strings kullanımı

// Kötü
[Fact]
public void Calculate_ReturnsCorrectValue()
{
    var result = calculator.Calculate("1001");
    Assert.Equal(42, result);
}

// İyi
[Fact]
public void Calculate_MaxValue_ReturnsCorrectValue()
{
    const string MAX_VALUE = "1001";
    const int EXPECTED_RESULT = 42;
    
    var result = calculator.Calculate(MAX_VALUE);
    Assert.Equal(EXPECTED_RESULT, result);
}

Multiple Act ve Assert kullanımı

// Kötü - Multiple Act
[Fact]
public void MultipleOperations_Test()
{
    var result1 = calculator.Add(1, 2);
    var result2 = calculator.Subtract(5, 3);
    
    Assert.Equal(3, result1);
    Assert.Equal(2, result2);
}

// İyi - Single responsibility
[Theory]
[InlineData(1, 2, 3)]
[InlineData(5, 10, 15)]
public void Add_TwoNumbers_ReturnsSum(int a, int b, int expected)
{
    var result = calculator.Add(a, b);
    Assert.Equal(expected, result);
}

İleri Seviye xUnit Teknikleri

Test Fixtures ve Setup/Teardown

Karmaşık test senaryolarında, test verilerinin hazırlanması için fixture’lar kullanılır:

public class DatabaseTestFixture : IDisposable
{
    public TestDatabase Database { get; private set; }
    
    public DatabaseTestFixture()
    {
        Database = new TestDatabase();
        Database.Initialize();
    }
    
    public void Dispose()
    {
        Database?.Cleanup();
    }
}

public class UserRepositoryTests : IClassFixture<DatabaseTestFixture>
{
    private readonly DatabaseTestFixture _fixture;
    
    public UserRepositoryTests(DatabaseTestFixture fixture)
    {
        _fixture = fixture;
    }
    
    [Fact]
    public void GetUser_ExistingId_ReturnsUser()
    {
        // Test implementation using _fixture.Database
    }
}

Parallel Test Execution

xUnit varsayılan olarak testleri paralel çalıştırır. Bu davranışı kontrol etmek için:

// Assembly seviyesinde paralel execution'ı devre dışı bırakma
[assembly: CollectionBehavior(DisableTestParallelization = true)]

// Specific collection için paralel execution kontrolü
[Collection("Database Tests")]
public class UserRepositoryTests
{
    // Tests that share database resources
}

Custom Attributes ve Extensions

xUnit’in extensibility özelliğini kullanarak özel attribute’lar oluşturabilirsiniz:

public class AutoMockDataAttribute : AutoDataAttribute
{
    public AutoMockDataAttribute() : base(() => new Fixture().Customize(new AutoMoqCustomization()))
    {
    }
}

[Theory]
[AutoMockData]
public void ProcessOrder_ValidOrder_CallsEmailService(
    [Frozen] Mock<IEmailService> emailMock,
    OrderService sut,
    Order order)
{
    // Test implementation
}

Code Coverage ve CI/CD Integration

Coverlet ile Code Coverage

Code coverage, testlerin kodun ne kadarını kapsadığını gösterir. Coverlet, .NET projeler için cross-platform coverage aracıdır:

# Coverage verisi toplama
dotnet test --collect:"XPlat Code Coverage"

# Report generation
dotnet tool install -g dotnet-reportgenerator-globaltool
reportgenerator -reports:"coverage.cobertura.xml" -targetdir:"coveragereport" -reporttypes:Html

Azure DevOps Pipeline Integration

- task: DotNetCoreCLI@2
  displayName: 'Run Tests'
  inputs:
    command: 'test'
    projects: '**/*Tests/*.csproj'
    arguments: '--configuration Release --collect:"XPlat Code Coverage"'

- task: PublishCodeCoverageResults@1
  inputs:
    codeCoverageTool: 'Cobertura'
    summaryFileLocation: '$(Agent.TempDirectory)/**/coverage.cobertura.xml'