Yazılım Test Türleri Nelerdir? .NET Test Örnekleri Yazıyoruz

14 Ağustos 2023 Ayaz .NET, ASP.NET, C#

 

Yazılım Test Türleri Nelerdir?

  1. Birim Testleri (Unit Tests): Yazılımın en küçük bileşenlerini (fonksiyonlar, sınıflar) izole ederek test etmeyi amaçlar. Bileşenin belirli girdilere karşılık beklenen çıktıları doğrulamak için kullanılırlar.

  2. Entegrasyon Testleri (Integration Tests): Farklı bileşenlerin bir araya geldiğinde nasıl çalıştığını test eder. Bileşenler arasındaki etkileşimleri ve veri akışını kontrol ederek bütün sistemin çalışabilirliğini doğrularlar.

  3. Fonksiyonel Testler (Functional Tests): Yazılımın belirli işlevlerini ve kullanım senaryolarını test etmek amacıyla gerçekleştirilen otomasyonlu testlerdir. Kullanıcı beklentilerini ve işlevselliği kontrol etmek için kullanılırlar.

  4. Sistem Testleri (System Tests): Bütün yazılımın tümünü bir arada test etmeyi amaçlar. Bütün bileşenleri entegre eder ve sistem düzeyinde doğrulamalar yapar.

  5. Kabul Testleri (Acceptance Tests): Yazılımın kullanıcı veya müşteri tarafından onaylanabilirliğini doğrulamayı hedefler. Kullanıcı senaryolarını ve iş gereksinimlerini test ederek yazılımın gereksinimlere uygun olduğunu belirlemeye çalışırlar.

  6. Performans Testleri (Performance Tests): Yazılımın belirli yük veya kullanım koşullarında nasıl performans gösterdiğini değerlendirir. Yanıt süreleri, işlem kapasitesi ve sistem stabilitesi gibi faktörleri ölçer.

  7. Yük Testleri (Load Tests): Belirli bir kullanım yoğunluğunda yazılımın nasıl davrandığını inceler. Sistemde aynı anda gerçekleşen işlemlerin etkilerini simüle eder.

  8. Dayanıklılık Testleri (Endurance Tests): Uzun süreli kullanım altında yazılımın nasıl davrandığını inceler. Bellek sızıntıları, kaynak tükenmeleri gibi durumları belirlemeye yöneliktir.

  9. Güvenlik Testleri (Security Tests): Potansiyel güvenlik açıklarını belirlemeye çalışır. Sistemdeki zayıf noktaları tespit ederek potansiyel saldırılara karşı direnci değerlendirir.

  10. Regrasyon Testleri (Regression Tests): Yeni eklenen kod veya yapılan değişikliklerin varolan işlevselliği olumsuz etkileyip etkilemediğini kontrol eder.

  11. Hata Durumu Testleri (Error Handling Tests): Yazılımın hata durumlarıyla nasıl başa çıktığını test eder. Öngörülemeyen hataların beklenen şekilde işlendiğini doğrular.

  12. Uzaktan Servis Testleri (Remote Service Tests): Harici hizmetler veya API'lerle etkileşimi test eder. Bu, dış servislerin sistemle uyumlu olduğunu doğrulamayı amaçlar.

  13. Dağıtım Testleri (Deployment Tests): Yazılımın farklı ortamlarda (örneğin, test, üretim) nasıl davrandığını kontrol eder. Farklı yapılandırmalarda test ederek uyumluluğu değerlendirir.

  14. Arayüz Testleri (Interface Tests): Yazılım bileşenlerinin birbirleriyle nasıl etkileşimde bulunduğunu test eder. Arayüzlerin ve API'lerin işbirliği içinde çalışmasını doğrular.

Bu liste, farklı test türlerinin bir kısmını içermektedir. Yazılım projeleri gereksinimlere, kullanım senaryolarına ve hedeflere göre farklı test çeşitlerini kullanabilir. Biz bu makalede sadece Unit, Integration ve Functional testleri inceleyeceğiz.

Yazılım Geliştirmenin Temel Taşı: Unit Testleri

Yazılım geliştirme sürecinde, kaliteli ve güvenilir bir ürün oluşturmak için birçok önemli adım bulunmaktadır. Bu adımlardan biri de "Unit Testleri"dir. Unit testleri, yazılımın en küçük parçalarını izole ederek test etmeyi amaçlayan otomasyonlu testlerdir. Bu testler, yazılım geliştiricilerin ve mühendislerin kodlarını daha güvenilir hale getirmelerini sağlayarak, yazılım projelerinin başarılı bir şekilde yönetilmesine yardımcı olur.

Unit Testi Nedir?

Unit testleri, yazılımın en küçük işlevsel birimlerini (fonksiyonlar, metotlar, sınıflar) izole ederek test etme yaklaşımını benimser. Bu testler, bir bileşenin belirli bir girdiye karşılık beklenen çıktıyı üreterek üretmediğini kontrol eder. Unit testleri, yazılımın temel yapı taşlarını denetleyerek, her bir parçanın beklenen davranışı sergilediğini doğrulamak amacıyla kullanılır.

Unit Testlerinin Özellikleri

Unit testleri, yazılım geliştirmenin farklı aşamalarında birçok avantaj sunar:

  1. Hata Ayıklama Kolaylığı: Unit testleri, kodunuzu hata ayıklamanızı kolaylaştırır. Bir bileşenin hatalı davrandığı durumları hızla tespit edebilir ve düzeltebilirsiniz.

  2. Kodun İyi Dökümantasyonu: Unit testleri, kodunuzun nasıl kullanılması gerektiğini ve beklenen sonuçların ne olması gerektiğini belgelemeye yardımcı olur.

  3. Kodun Güvenliği: Mevcut işlevselliği korumak ve yeni kodun mevcut işlevselliği bozmamasını sağlamak için unit testleri kullanılır.

  4. Refactoring Desteği: Kodunuzu yeniden düzenlemek veya geliştirmek istediğinizde, unit testleri mevcut işlevselliği koruduğunuzdan emin olmanıza yardımcı olur.

  5. Sürekli Entegrasyon ve Teslimat Desteği: Unit testleri, sürekli entegrasyon ve sürekli teslimat (CI/CD) süreçlerinin bir parçası olarak yazılımın istikrarını sağlar.

Unit Testi Yazma Süreci

Unit testleri yazarken genellikle şu adımlar izlenir:

  1. Test Senaryolarını Belirleme: Test edilecek kod parçasının hangi senaryolar altında nasıl davranması gerektiğini belirleyin.

  2. Test Sınıfını Oluşturma: Unit testlerini bir araya toplamak için bir test sınıfı oluşturun.

  3. Test Metotlarını Yazma: Her bir test senaryosu için ayrı bir test metodu oluşturun. Bu metotlar, test edilecek kod parçasını çağırarak beklenen sonuçları kontrol eder.

  4. Testleri Çalıştırma: Unit test çerçevesi (örneğin xUnit, NUnit) kullanılarak oluşturulan testleri çalıştırın. Test sonuçları raporlanır.

  5. Sonuçları İnceleme ve Düzeltme: Test sonuçlarını inceleyin. Eğer bir test başarısız olursa, hatanın nedenini tespit edip düzeltin.

Unit testleri, yazılım geliştirme sürecinin vazgeçilmez bir parçasıdır. Bu testler, yazılımın en küçük bileşenlerini izole ederek test etmenizi sağlar, böylece kodunuzun beklenen şekilde çalıştığından emin olabilirsiniz. Unit testleri yazılımın kalitesini artırırken, hata ayıklama süreçlerini kolaylaştırır ve sürdürülebilir bir kod tabanı oluşturmanıza yardımcı olur.

Entegrasyon Testleri: Yazılımın Bütünselliğini Doğrulamanın Anahtarı

Yazılım geliştirme süreci, farklı bileşenlerin bir araya getirilmesi ve entegre edilmesiyle oluşturulan karmaşık bir yapıya sahiptir. Bu bileşenlerin bir araya gelerek düzgün bir şekilde çalışması, yazılımın işlevselliği ve güvenilirliği açısından kritik önem taşır. İşte bu noktada devreye "Entegrasyon Testleri" girer. Entegrasyon testleri, farklı bileşenlerin nasıl bir arada çalıştığını ve birbiriyle uyumlu olup olmadığını değerlendiren testlerdir.

Entegrasyon Testi Nedir?

Entegrasyon testleri, yazılım geliştirme sürecinde farklı bileşenlerin birleştiği noktada gerçekleştirilen otomasyonlu testlerdir. Bu testler, farklı modüllerin, sınıfların, servislerin veya sistem bileşenlerinin bir araya gelmesi sonucu nasıl davrandığını değerlendirir. Entegrasyon testleri, farklı bileşenlerin işbirliği içinde düzgün çalıştığını ve beklenen sonuçları ürettiğini doğrulamayı hedefler.

Entegrasyon Testlerinin Önemi

Entegrasyon testleri, yazılım projelerinin bir dizi avantajını sunar:

  1. Bütünsel İşleyişin Doğrulanması: Entegrasyon testleri, yazılımın bileşenlerinin bir araya gelerek bütünsel işleyişi sağladığını doğrulamak için kullanılır. Bu, yazılımın kullanım sırasında beklenen şekilde çalışmasını sağlar.

  2. Bileşenler Arası Etkileşimin Test Edilmesi: Yazılım projeleri genellikle farklı bileşenlerin birbiriyle etkileşim içinde olduğu karmaşık yapılar içerir. Entegrasyon testleri, bu etkileşimleri test ederek veri akışını ve iletişimi kontrol eder.

  3. Hata ve Uyumsuzlukların Tespit Edilmesi: Farklı bileşenlerin bir araya gelmesiyle oluşabilecek hatalar, uyumsuzluklar veya veri kayıpları gibi problemler entegrasyon testleri ile tespit edilebilir. Bu, hataların daha erken aşamada çözülmesine olanak sağlar.

  4. Mevcut Fonksiyonelliğin Onaylanması: Entegrasyon testleri, yazılımın gereksinimlere uygun olarak çalıştığını ve mevcut işlevselliğin doğrulandığını sağlar.

Entegrasyon Testi Aşamaları

Entegrasyon testleri genellikle şu aşamaları içerir:

  1. Entegrasyon Planlaması: Hangi bileşenlerin test edileceği, hangi senaryoların oluşturulacağı ve hangi test yaklaşımının kullanılacağı gibi detaylar belirlenir.

  2. Bileşen Seçimi ve Hazırlığı: Test edilecek bileşenler seçilir ve gerekli ortam hazırlıkları yapılır.

  3. Test Senaryolarının Oluşturulması: Bileşenlerin bir araya geldiği senaryolar oluşturulur. Bu senaryolar, bileşenlerin nasıl etkileşimde bulunduğunu ve veri akışını içerir.

  4. Test Senaryolarının Yürütülmesi: Oluşturulan senaryolar otomasyonlu test araçları veya manuel olarak çalıştırılır. Bileşenlerin etkileşimi, iletişim ve sonuçlar gözlemlenir.

  5. Sonuçların Analizi: Test sonuçları incelenir. Eğer bir senaryo başarısız olursa, hatanın nedeni tespit edilir ve düzeltilir.

Farklı Entegrasyon Test Yaklaşımları

  1. Büyük Resim Testi (Top-down Testing): Bu yaklaşımda, üst seviyedeki bileşenler önce test edilir. Ardından, alt seviyedeki bileşenlere doğru testler devam eder.

  2. Küçük Resim Testi (Bottom-up Testing): Bu yaklaşımda ise, en düşük seviyede bulunan bileşenler önce test edilir ve ardından üst seviyedeki bileşenlere doğru testler devam eder.

Entegrasyon testleri, yazılım projelerinde farklı bileşenlerin bir araya gelerek nasıl çalıştığını ve işbirliği yaptığını doğrulayan önemli bir test aşamasını temsil eder. Bu testler, bileşenler arasında uyumsuzlukları ve iletişim sorunlarını erken aşamada tespit ederek yazılımın güvenilirliğini artırır. Entegrasyon testleri, karmaşık projelerde bileşenlerin işbirliği içinde düzgün çalışmasını sağlarken, kullanıcıların beklediği bütünsel işleyişi garanti altına alır.

Yazılımın Kullanılabilirliğini Doğrulama Aracı: Fonksiyonel Testler

Yazılım geliştirme sürecinde, kullanıcıların beklentilerini karşılayan, doğru ve güvenilir bir ürün oluşturmak büyük önem taşır. Bu amaçla, yazılımın işlevselliğini ve kullanılabilirliğini doğrulamak için "Fonksiyonel Testler" kullanılır. Fonksiyonel testler, yazılımın belirli işlevlerini ve kullanım senaryolarını test etmek amacıyla gerçekleştirilen otomasyonlu testlerdir.

Fonksiyonel Testi Nedir?

Fonksiyonel testler, yazılımın kullanıcıların beklentilerini karşılayıp karşılamadığını ve belirli işlevleri doğru bir şekilde yerine getirip getirmediğini doğrulamak amacıyla gerçekleştirilen testlerdir. Bu testler, kullanıcı deneyimini ve yazılımın işlevselliğini doğrulamak için önemli bir araçtır. Fonksiyonel testler, yazılımın dışarıdan erişilebilen bileşenlerini (genellikle kullanıcı arayüzünü) test ederek, girdi verileri ile beklenen çıktıları karşılaştırırlar.

Fonksiyonel Testlerin Özellikleri

Fonksiyonel testler, yazılım projelerinde bir dizi avantajı beraberinde getirir:

  1. Kullanılabilirliği Doğrulama: Fonksiyonel testler, yazılımın kullanıcıların ihtiyaçlarını ve beklentilerini karşılayıp karşılamadığını doğrulamak için kullanılır. Kullanıcıların işlevselliği doğru bir şekilde kullanabilmesini sağlar.

  2. Beklenen Sonuçları Kontrol: Testler, belirli girdi verileri ile yazılımın nasıl tepki verdiğini ve beklenen sonuçları üreterek üretmediğini kontrol eder.

  3. Hata Durumlarını Saptama: Fonksiyonel testler, hatalı girişleri veya beklenmeyen kullanım senaryolarını test etmek için kullanılır. Bu sayede yazılımın nasıl hata durumlarıyla başa çıktığını gözlemleyebiliriz.

  4. Kullanıcı Arayüzünün Test Edilmesi: Fonksiyonel testler, kullanıcı arayüzünün düzgün çalışıp çalışmadığını ve kullanıcı deneyiminin uygun olduğunu değerlendirmek için kullanılır.

  5. Farklı Senaryoların Test Edilmesi: Testler, farklı kullanım senaryolarını simüle ederek yazılımın farklı durumlarda nasıl tepki verdiğini değerlendirir.

Fonksiyonel Test Süreci

Fonksiyonel testler genellikle şu aşamaları içerir:

  1. Gereksinim Analizi: İlk adım olarak, yazılımın gereksinimleri ve kullanım senaryoları analiz edilir. Hangi işlevlerin ve senaryoların test edileceği belirlenir.

  2. Test Senaryolarının Tasarımı: Fonksiyonel test senaryoları oluşturulur. Her senaryo, belirli adımları içerir ve kullanıcının yazılımı nasıl kullanacağını simüle eder.

  3. Test Verilerinin Hazırlanması: Test senaryolarını yürütmek için gereken veriler hazırlanır. Örnek girdi verileri, beklenen çıktılar ve test verileri içerebilir.

  4. Test Senaryolarının Yürütülmesi: Oluşturulan test senaryoları otomasyonlu test araçları kullanılarak yürütülür. Girdi verileri sağlanır, sistemin tepkisi izlenir ve çıktılar karşılaştırılır.

  5. Sonuçların Analizi: Test sonuçları incelenir ve her bir senaryonun beklenen sonuçlarıyla uyumlu olup olmadığı değerlendirilir. Eğer beklenen sonuçlarla uyuşmuyorsa, bir hata raporu oluşturulur.

Fonksiyonel testler, yazılımın kullanılabilirliğini ve işlevselliğini doğrulamak için kullanılan temel bir test türüdür. Bu testler, yazılımın kullanıcıların beklentilerini karşılayıp karşılamadığını doğrulamak ve beklenen sonuçların elde edilip edilmediğini kontrol etmek için kullanılır. Fonksiyonel testler, yazılımın kullanıcı deneyiminin kalitesini artırarak, yazılım projelerinin başarılı bir şekilde tamamlanmasına katkıda bulunur.

Aşağıda ASP.NET Core ve xUnit kullanarak farklı türlerde testlerin olduğu bir örnek proje ve açıklamalarını bulabilirsiniz. Bu projede, basit bir blog uygulamasının temel işlevlerini test edeceğiz: bir makale oluşturma, kullanıcı girişi ve makaleleri listeleme.

xUnit Nedir?

xUnit, .NET platformunda kullanılan, açık kaynaklı bir unit test çerçevesidir. Unit testler, yazılımın en küçük bileşenlerinin (fonksiyonlar, metotlar, sınıflar) davranışlarını ve işlevselliğini test etmek amacıyla oluşturulan otomasyonlu testlerdir. xUnit, bu tür testlerin yazılmasını, yönetilmesini ve çalıştırılmasını kolaylaştırmak için tasarlanmıştır.

xUnit, birçok özelliği ve esnekliği ile geliştiricilere test yazımında ve sürdürülebilir bir test tabanı oluşturmada yardımcı olur. Bazı özellikleri şunlardır:

  1. Öznitelik Tabanlı: xUnit, test metodlarını öznitelikler (attributes) ile işaretler. Bu sayede sadece test metodlarını adlandırmak yerine, metot adından ziyade anlam taşıyan öznitelikler kullanarak testleri gruplandırmak ve yönetmek mümkün olur.

  2. Parametreli Testler: xUnit, TheoryAttribute ve InlineDataAttribute gibi öznitelikler ile parametreli testleri destekler. Bu sayede aynı test metodu farklı girdi verileri ile tekrar tekrar çalıştırılabilir.

  3. Paralel Test Çalıştırma: xUnit, testleri paralel olarak çalıştırma yeteneğine sahiptir. Bu, test sürelerini kısaltabilir ve performansı artırabilir.

  4. Zengin Doğrulama (Assertion) Kütüphanesi: xUnit, birçok farklı assert (doğrulama) metodunu destekler. Bu sayede test sonuçlarını ve beklenen sonuçları karşılaştırmak ve doğrulamak kolaylaşır.

  5. Özelleştirilebilir: xUnit, test çerçevesini özelleştirme ve genişletme imkanı sunar. Bu, özelleştirilmiş test senaryoları oluşturmanıza ve mevcut işleyişi değiştirmenize olanak tanır.

  6. Dinamik Veri Üretimi: xUnit, veri üretme senaryolarını belirlemek ve dinamik olarak testlerinizi çalıştırmak için kullanabileceğiniz bazı özelleştirilmiş öznitelikler içerir.

xUnit, açık kaynaklı ve geniş bir topluluk tarafından desteklenen bir çerçeve olduğundan, sürekli olarak geliştirilir ve güncellenir. Bu nedenle, .NET geliştiricileri arasında yaygın bir tercih haline gelmiştir.

FactAttribute: Bu öznitelik, bir test metodunu işaretler ve bu metodun bir "gerçek" (fact) olarak kabul edildiğini belirtir. Bu metodun doğrulama (assertion) işlemleri içermesi beklenir.

Örnek kullanım:

[Fact]
public void TestMethod()
{
    // Test kodları ve doğrulama işlemleri burada yer alır
}

TheoryAttribute: Bu öznitelik, parametreli testleri tanımlamak için kullanılır. Farklı senaryolarda aynı test metodunun çalıştırılmasını sağlar.

Örnek kullanım:

[Theory]
[InlineData(2, 3, 5)]
[InlineData(4, 5, 9)]
public void Add_ShouldReturnSum(int a, int b, int expected)
{
    // Arrange
    var calculator = new Calculator();

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

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

InlineDataAttribute: Bu öznitelik, TheoryAttribute ile birlikte kullanıldığında, test metoduna farklı parametre setleri ile çalışma imkanı sağlar.

Örnek kullanım:

[Theory]
[InlineData(2, 3, 5)]
[InlineData(4, 5, 9)]
public void Add_ShouldReturnSum(int a, int b, int expected)
{
    // Test kodları ve doğrulama işlemleri burada yer alır
}

InlineDataAttribute: Bu öznitelik, TheoryAttribute ile birlikte kullanıldığında, test metoduna farklı parametre setleri ile çalışma imkanı sağlar.

Örnek kullanım:

[Theory]
[InlineData(2, 3, 5)]
[InlineData(4, 5, 9)]
public void Add_ShouldReturnSum(int a, int b, int expected)
{
    // Test kodları ve doğrulama işlemleri burada yer alır
}

Assert: xUnit, birçok farklı assert (doğrulama) methodunu destekler. Bu methodlar, test sonuçlarını ve beklenen sonuçları karşılaştırmak için kullanılır. Örnek assert methodları:

  • Assert.Equal(expected, actual): İki değeri karşılaştırarak eşitlik durumunu kontrol eder. Eğer beklenen ve gerçek değerler eşit değilse test başarısız olur.

  • Assert.NotEqual(expected, actual): İki değeri karşılaştırarak eşitlik durumunu kontrol eder. Eğer beklenen ve gerçek değerler eşitse test başarısız olur.

  • Assert.True(expression): Bir koşulu kontrol eder. Eğer koşul doğru değilse test başarısız olur.

  • Assert.False(expression): Bir koşulu kontrol eder. Eğer koşul yanlışsa test başarısız olur.

  • Assert.Null(object): Bir nesnenin null olup olmadığını kontrol eder. Eğer nesne null değilse test başarısız olur.

  • Assert.NotNull(object): Bir nesnenin null olup olmadığını kontrol eder. Eğer nesne null ise test başarısız olur.

  • Assert.Empty(collection): Bir koleksiyonun boş olup olmadığını kontrol eder. Eğer koleksiyon boş değilse test başarısız olur.

  • Assert.NotEmpty(collection): Bir koleksiyonun boş olup olmadığını kontrol eder. Eğer koleksiyon boş ise test başarısız olur.

  • Assert.Contains(expected, collection): Bir koleksiyonun belirli bir öğeyi içerip içermediğini kontrol eder. Eğer koleksiyon belirli öğeyi içermiyorsa test başarısız olur.

  • Assert.DoesNotContain(expected, collection): Bir koleksiyonun belirli bir öğeyi içerip içermediğini kontrol eder. Eğer koleksiyon belirli öğeyi içeriyorsa test başarısız olur.

  • Assert.IsType(expectedType, object): Bir nesnenin belirli bir türde olup olmadığını kontrol eder. Eğer nesne belirli türde değilse test başarısız olur.

  • Assert.IsNotType(expectedType, object): Bir nesnenin belirli bir türde olup olmadığını kontrol eder. Eğer nesne belirli türde ise test başarısız olur.

  • Assert.Throws(exceptionType, action): Bir işlemin belirli bir türde istisna fırlatıp fırlatmadığını kontrol eder. Eğer istisna fırlatılmazsa veya farklı bir istisna fırlatılırsa test başarısız olur.

CollectionAssert: xUnit, koleksiyonlar üzerinde doğrulama yapmak için de methodlar sunar. Örnek kullanım:

  • CollectionAssert.All(collection, predicate): Bir koleksiyondaki tüm öğelerin belirtilen koşulu sağladığını doğrular.
  • CollectionAssert.Contains(collection, item): Bir koleksiyonun belirli bir öğeyi içerdiğini doğrular.

Bu örnekler, xUnit ile yazılan testlerde sıkça kullanılan methodları ve yapıları göstermektedir. xUnit dökümantasyonu, daha fazla bilgi ve detay için başvurulabilecek önemli bir kaynaktır.

1. Örnek Proje Oluşturma

Öncelikle, bir ASP.NET Core 6 projesi oluşturup xUnit test projelerini eklememiz gerekiyor.

Proje Oluşturma:

dotnet new web -n BlogApp
cd BlogApp
dotnet new xunit -n BlogApp.UnitTests
dotnet new xunit -n BlogApp.FunctionalTests
dotnet new xunit -n BlogApp.IntegrationTests

2. Makale Sınıfının ve Veritabanının Oluşturulması

Article adında bir sınıf oluşturup içerisine makale özelliklerini ekleyelim. Ayrıca, bu örnekte hafıza üzerinde çalışan basit bir InMemoryDatabase kullanacağız.

Article.cs:

public class Article
{
    public int Id { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }
}

ApplicationDbContext.cs:

public class ApplicationDbContext
{
    public List<Article> Articles { get; set; } = new List<Article>();
}

3. Makale Servisinin ve Controller'ın Oluşturulması

Makale işlemlerini gerçekleştirecek olan bir servis ve bir controller oluşturalım.

ArticleService.cs:

public class ArticleService
{
    private readonly ApplicationDbContext _dbContext;

    public ArticleService(ApplicationDbContext dbContext)
    {
        _dbContext = dbContext;
    }

    public void CreateArticle(Article article)
    {
        _dbContext.Articles.Add(article);
    }

    public List<Article> GetAllArticles()
    {
        return _dbContext.Articles;
    }
}

ArticlesController.cs:

[ApiController]
[Route("api/[controller]")]
public class ArticlesController : ControllerBase
{
    private readonly ArticleService _articleService;

    public ArticlesController(ArticleService articleService)
    {
        _articleService = articleService;
    }

    [HttpGet]
    public ActionResult<IEnumerable<Article>> GetAll()
    {
        var articles = _articleService.GetAllArticles();
        return Ok(articles);
    }

    [HttpPost]
    public IActionResult Create(Article article)
    {
        _articleService.CreateArticle(article);
        return CreatedAtAction(nameof(GetAll), null);
    }
}

4. Unit Testlerin Oluşturulması

Unit testleri, makale servisini ve controller'ını test etmek için kullanacağız.

ArticleServiceTests.cs:

public class ArticleServiceTests
{
    [Fact]
    public void CreateArticle_ShouldAddArticleToDatabase()
    {
        // Arrange
        var dbContext = new ApplicationDbContext();
        var service = new ArticleService(dbContext);
        var article = new Article { Id = 1, Title = "Test Article", Content = "Test Content" };

        // Act
        service.CreateArticle(article);

        // Assert
        Assert.Single(dbContext.Articles);
    }

    [Fact]
    public void GetAllArticles_ShouldReturnAllArticles()
    {
        // Arrange
        var dbContext = new ApplicationDbContext();
        dbContext.Articles.Add(new Article { Id = 1, Title = "Article 1", Content = "Content 1" });
        dbContext.Articles.Add(new Article { Id = 2, Title = "Article 2", Content = "Content 2" });
        var service = new ArticleService(dbContext);

        // Act
        var articles = service.GetAllArticles();

        // Assert
        Assert.Equal(2, articles.Count);
    }
}

ArticlesControllerTests.cs:

public class ArticlesControllerTests
{
    [Fact]
    public void GetAll_ShouldReturnAllArticles()
    {
        // Arrange
        var dbContext = new ApplicationDbContext();
        dbContext.Articles.Add(new Article { Id = 1, Title = "Article 1", Content = "Content 1" });
        dbContext.Articles.Add(new Article { Id = 2, Title = "Article 2", Content = "Content 2" });
        var service = new ArticleService(dbContext);
        var controller = new ArticlesController(service);

        // Act
        var result = controller.GetAll();

        // Assert
        var okResult = Assert.IsType<OkObjectResult>(result.Result);
        var articles = Assert.IsAssignableFrom<IEnumerable<Article>>(okResult.Value);
        Assert.Equal(2, articles.Count());
    }

    [Fact]
    public void Create_ShouldCreateArticle()
    {
        // Arrange
        var dbContext = new ApplicationDbContext();
        var service = new ArticleService(dbContext);
        var controller = new ArticlesController(service);
        var article = new Article { Id = 1, Title = "Test Article", Content = "Test Content" };

        // Act
        var result = controller.Create(article);

        // Assert
        Assert.IsType<CreatedAtActionResult>(result);
        Assert.Single(dbContext.Articles);
    }
}

5. Functional Testlerin Oluşturulması

Functional testler, API endpoint'lerini simüle ederek gerçek kullanım durumlarını test eder.

ArticlesControllerFunctionalTests.cs:

public class ArticlesControllerFunctionalTests : IClassFixture<WebApplicationFactory<BlogApp.Startup>>
{
    private readonly WebApplicationFactory<BlogApp.Startup> _factory;

    public ArticlesControllerFunctionalTests(WebApplicationFactory<BlogApp.Startup> factory)
    {
        _factory = factory;
    }

    [Fact]
    public async Task GetAll_ReturnsSuccessResult()
    {
        // Arrange
        var client = _factory.CreateClient();

        // Act
        var response = await client.GetAsync("/api/articles");

        // Assert
        response.EnsureSuccessStatusCode();
    }

    [Fact]
    public async Task Create_ReturnsSuccessResult()
    {
        // Arrange
        var client = _factory.CreateClient();
        var content = new StringContent(
            @"{ ""title"": ""Test Article"", ""content"": ""Test Content"" }",
            Encoding.UTF8,
            "application/json");

        // Act
        var response = await client.PostAsync("/api/articles", content);

        // Assert
        response.EnsureSuccessStatusCode();
    }
}

6. Integration Testlerin Oluşturulması

Integration testleri, gerçekten çalışan sunucu üzerinde tüm uygulamanın davranışını test eder.

ArticlesControllerIntegrationTests.cs:

public class ArticlesControllerIntegrationTests : IClassFixture<WebApplicationFactory<BlogApp.Startup>>
{
    private readonly WebApplicationFactory<BlogApp.Startup> _factory;

    public ArticlesControllerIntegrationTests(WebApplicationFactory<BlogApp.Startup> factory)
    {
        _factory = factory;
    }

    [Fact]
    public async Task GetAll_ReturnsSuccessResult()
    {
        // Arrange
        var client = _factory.CreateClient();

        // Act
        var response = await client.GetAsync("/api/articles");

        // Assert
        response.EnsureSuccessStatusCode();
        var articles = await response.Content.ReadFromJsonAsync<IEnumerable<Article>>();
        Assert.NotNull(articles);
    }

    [Fact]
    public async Task Create_ReturnsSuccessResult()
    {
        // Arrange
        var client = _factory.CreateClient();
        var content = new StringContent(
            @"{ ""title"": ""Test Article"", ""content"": ""Test Content"" }",
            Encoding.UTF8,
            "application/json");

        // Act
        var response = await client.PostAsync("/api/articles", content);

        // Assert
        response.EnsureSuccessStatusCode();
        var createdArticle = await response.Content.ReadFromJsonAsync<Article>();
        Assert.NotNull(createdArticle);
    }
}

7. Testlerin Çalıştırılması

Testleri çalıştırmak için terminalde aşağıdaki komutları kullanabilirsiniz:

cd BlogApp.UnitTests
dotnet test

cd ../BlogApp.FunctionalTests
dotnet test

cd ../BlogApp.IntegrationTests
dotnet test

Bu komutlar, ilgili test projelerini çalıştırır ve sonuçları raporlar. Eğer tüm testler başarılıysa, herhangi bir hata mesajı almadan başarılı bir şekilde sonuçlandığını göreceksiniz.

Umarım bu örnek proje, ASP.NET Core  ve xUnit ile Unit, Functional ve Integration testlerin nasıl yapıldığını anlamak için faydalı bir kaynak olur.

Sağlıcakla kalın.

 

Yorumlar kapalı