Birim test uygulaması mantığı ve güvensiz dil yapıları arasındaki çizgi nerededir?

Bunun gibi bir fonksiyon düşünün:

function savePeople(dataStore, people) {
    people.forEach(person => dataStore.savePerson(person));
}

Bu şekilde kullanılabilir:

myDataStore = new Store('some connection string', 'password');
myPeople = ['Joe', 'Maggie', 'John'];
savePeople(myDataStore, myPeople);

Bunun kendi birim testlerine sahip olduğunu veya satıcı tarafından verildiğini varsayalımStore . Her durumda, biz güveniyoruz Store. Ayrıca, hata işlemenin - örneğin veri tabanı kopma hatalarının - sorumluluğunun olmadığını varsayalım savePeople. Aslında, mağazanın kendisinin muhtemelen hiçbir şekilde hata yapamayacağı sihirli bir veritabanı olduğunu varsayalım . Bu varsayımlar göz önüne alındığında , soru şudur:

Birimce savePeople()test edilmeli mi yoksa bu tür testler yerleşik forEachdil yapısını test etmeyi mi gerektiriyor?

Elbette, her bir kişi için bir defa denen bir alay dataStoreve iddiaya girebiliriz dataStore.savePerson(). Bu tür bir testin uygulama değişikliklerine karşı güvenlik sağladığını kesinlikle iddia edebilirsiniz: örneğin, forEachgeleneksel bir fordöngü ile değiştirmeye karar verirsek , ya da başka bir yineleme yöntemi. Yani test tamamen önemsiz değil . Ve yine de çok yakın görünüyor ...

İşte daha verimli olabilecek başka bir örnek. Başka hiçbir şeyi veya işlevi koordine etmekten başka bir şey yapmayan bir işlev düşünün. Örneğin:

function bakeCookies(dough, pan, oven) {
    panWithRawCookies = pan.add(dough);
    oven.addPan(panWithRawCookies);
    oven.bakeCookies();
    oven.removePan();
}

Bunun gibi bir fonksiyon, olması gerektiğini düşündüğünüz varsayılarak, nasıl test edilmeli? Beni sadece alay etmez birim testinin her türlü hayal etmek çok zor dough, panve oven, ardından yöntemleri üzerlerinde denir iddia. Ancak böyle bir test, işlevin tam olarak uygulanmasını çoğaltmaktan başka bir şey yapmamaktadır.

Bu fonksiyonun anlamlı bir kara kutu şeklinde test edilememesi, fonksiyonun kendisiyle ilgili bir tasarım hatasını gösteriyor mu? Eğer öyleyse, nasıl geliştirilebilir?

Örneği motive eden soruya daha fazla netlik kazandırmak için bakeCookies, testler eklemeye çalışırken ve eski kodlara yeniden bakarken karşılaştığım daha gerçekçi bir senaryo ekleyeceğim.

Bir kullanıcı yeni bir hesap oluşturduğunda, bazı şeylerin olması gerekir: 1) veritabanında yeni bir kullanıcı kaydı oluşturulması gerekir 2) karşılama e-postası gönderilir 3) kullanıcının IP adresinin dolandırıcılık için kaydedilmesi gerekir amaçlar.

Bu nedenle, tüm "yeni kullanıcı" adımlarını birbirine bağlayan bir yöntem oluşturmak istiyoruz:

function createNewUser(validatedUserData, emailService, dataStore) {
  userId = dataStore.insertUserRecord(validateduserData);
  emailService.sendWelcomeEmail(validatedUserData);
  dataStore.recordIpAddress(userId, validatedUserData.ip);
}

Bu yöntemlerden herhangi biri bir hata atarsa, hatanın uygun gördüğü şekliyle işleyebilmesi için çağrının koduna kabarmasını istiyoruz. API kodu tarafından çağrılıyorsa, hatayı uygun bir http yanıt koduna çevirebilir. Bir web arayüzü tarafından aranıyorsa, hatayı kullanıcıya gösterilecek şekilde uygun bir mesaja çevirebilir. Mesele şu ki, bu fonksiyon atılabilecek hataları nasıl idare edeceğini bilmiyor.

Kafamın özü, böyle bir işlevi test etmek için testin kendisinde tam olarak uygulamanın tekrarlanmasının gerekli göründüğüdür (yöntemlerin belli bir sıradaki alaylara çağrılmasıyla) ve bu yanlış görünüyor.

Meli savePeople()birim test edilecek? Evet. dataStore.savePersonİşe ya da db bağlantısının çalıştığını, hatta çalıştığını test etmiyorsunuz foreach. savePeopleKontratı ile verdiği sözü yerine getiren testleri siz yapıyorsunuz .

Bu senaryoyu hayal edin: Birisi kod tabanının büyük bir refactorünü yapar forEachve uygulamanın bir bölümünü yanlışlıkla kaldırır, böylece her zaman yalnızca ilk öğeyi kaydeder. Bunu yakalamak için bir birim testi yapmak istemez miydin?

Genellikle bu tür bir soru, insanlar "testten sonra" gelişme yaptığında ortaya çıkar. Bu soruna, uygulamadan önce testlerin geldiği TDD bakış açısıyla yaklaşın ve kendinize bu soruyu tekrar bir alıştırma olarak sorun.

En azından genellikle dışarıda olan TDD başvurumda, uygulandıktan savePeoplesonra olduğu gibi bir işlevi yerine getirmiyordum savePerson. savePeopleVe savePersonfonksiyonları olarak başlayacak ve aynı birim testlerinden test odaklı edilir; ikisi arasındaki ayrım yeniden yapılanma aşamasında birkaç testten sonra ortaya çıkacaktır. Bu çalışma şekli aynı zamanda işlevin nerede olması savePeoplegerektiği - serbest bir işlev mi yoksa bir parçası mı olduğu sorusunu da ortaya çıkarır dataStore.

Sonunda, testler doğru bir kaydedebilirsiniz eğer sadece kontrol etmem Personde Store, aynı zamanda pek çok kişi. Bu aynı zamanda, diğer kontrollerin gerekli olup olmadığını sorgulamama da yol açar, örneğin, " savePeopleİşlevin atomik olduğundan emin olmalı mıyım , tümünü mi yoksa hiçbirini mi kaydetmeliyim?" saklanmıyor? Bu hatalar nasıl görünür? ", vb. Bütün bunlar, sadece bir forEachveya başka bir yineleme biçiminin kullanımını kontrol etmekten çok daha fazla miktardadır .

Aynı anda birden fazla kişiyi kurtarmanın şartı sonra geldiyse de, savePersonzaten teslim edildi, sonra ben mevcut testleri güncellemek istiyorum savePersonyeni işlevi aracılığıyla çalıştırmak için savePeople, emin hala basitçe ilk başta temsilciliği vererek bir kişiyi kurtarabilir yapım Daha sonra davranışı atomik yapmanın gerekip gerekmediğini düşünerek yeni testler yoluyla davranışı bir den fazla test edin.

SavePeople () birim test edilmeli

Evet, olmalı. Ancak test koşullarınızı uygulamadan bağımsız bir şekilde yazmaya çalışın. Örneğin, kullanım örneğinizi birim testine dönüştürmek:

function testSavePeople() {
    myDataStore = new Store('some connection string', 'password');
    myPeople = ['Joe', 'Maggie', 'John'];
    savePeople(myDataStore, myPeople);
    assert(myDataStore.containsPerson('Joe'));
    assert(myDataStore.containsPerson('Maggie'));
    assert(myDataStore.containsPerson('John'));
}

Bu test çok şey yapar:

• işlevin sözleşmesini doğrular savePeople()
• uygulanması umurunda değil savePeople()
• örnek kullanımını belgeliyor savePeople()

Veri deposunu hala alay / taslak / taklit edebileceğinizi unutmayın. Bu durumda, açık fonksiyon çağrıları için kontrol yapmazdım ama işlemin sonucunu kontrol ederim. Bu şekilde testim gelecekteki değişikliklere / refaktörlere hazırlanır.

Örneğin, veri deposu uygulamanız saveBulkPerson()gelecekte bir yöntem sağlayabilir - şimdi savePeople()kullanımının uygulanmasında yapılan bir değişiklik , beklendiği saveBulkPerson()kadar uzun sürdüğü sürece ünite testini saveBulkPerson()bozmaz. Ve eğer bir saveBulkPerson()şekilde beklendiği gibi çalışmazsa, birim testiniz bunu yakalayacaktır.

ya da bu tür testler, forEach dil yapısının yerleşik olarak test edilmesini sağlar mı?

Belirtildiği gibi, uygulama için değil (entegrasyon testleri yapmıyorsanız - o zaman belirli işlev çağrılarını kullanmak kullanımda olabilir) beklenmeyen sonuçları ve işlev arayüzünü test etmeye çalışın. Bir işlevi uygulamak için birden fazla yol varsa, bunların tümü birim testinizde çalışmalıdır.

Sorunun güncellenmesiyle ilgili olarak:

Durum değişikliklerini test edin! Örneğin bazı hamurlar kullanılacaktır. Senin uygulanmasına göre, kullanılan miktarı iddia doughsığar panveya iddia doughtüketilir. panİşlev çağrısından sonra çerezleri içerdiğini kabul edin . ovenBoş olduğunu ve eskisi gibi aynı durumda olduğunu kabul edin.

Ek testler için son durumları doğrulayın: ovenAramadan önce boş değilse ne olur ? Yeterli yoksa ne olur dough? Eğer panzaten dolu?

Bu testler için gerekli tüm verileri hamur, tava ve fırın nesnelerinden çıkarabilmelisiniz. İşlev çağrılarını yakalamaya gerek yok. Fonksiyonu, uygulaması sizin için uygun olmayacak gibi düşünün!

Aslında, çoğu TDD kullanıcısı, fonksiyonlarını yazmadan önce testlerini yapar, böylece gerçek uygulamaya bağlı olmazlar.

En son eklemeniz için:

Bir kullanıcı yeni bir hesap oluşturduğunda, bazı şeylerin olması gerekir: 1) veritabanında yeni bir kullanıcı kaydı oluşturulması gerekir 2) karşılama e-postası gönderilir 3) kullanıcının IP adresinin dolandırıcılık için kaydedilmesi gerekir amaçlar.

Bu nedenle, tüm "yeni kullanıcı" adımlarını birbirine bağlayan bir yöntem oluşturmak istiyoruz:

function createNewUser(validatedUserData, emailService, dataStore) {
    userId = dataStore.insertUserRecord(validateduserData);
    emailService.sendWelcomeEmail(validatedUserData);
    dataStore.recordIpAddress(userId, validatedUserData.ip);
}

Bunun gibi bir fonksiyon için, ack / stub / fake (ne daha genel görünüyorsa) dataStoreve emailServiceparametrelerini alayım. Bu işlev kendi başına herhangi bir parametre üzerinde herhangi bir durum geçişi yapmaz, onları bazılarının yöntemlerine devreder. Fonksiyon çağrısının 4 şey yaptığını doğrulamaya çalışacağım:

• bir kullanıcıyı veri deposuna ekledi
• bir hoşgeldin e-postası (veya en azından karşılık gelen yöntem olarak adlandırılır) gönderdi
• kullanıcıların IP'sini veri deposuna kaydetti
• karşılaştığı herhangi bir istisnayı / hatayı temsil etti (varsa)

İlk 3 denetler mocks, taslakları veya sahte ile yapılabilir dataStoreve emailService(gerçekten test ederken e-postalar göndermek istemiyorum). Bazı yorumlar için bunu aramam gerektiğinden, bunlar arasındaki farklar:

• Sahte, orijinalle aynı şekilde davranan ve belli bir ölçüde ayırt edilemeyen bir nesnedir. Kodu normalde testlerde tekrar kullanılabilir. Bu, örneğin, bir veritabanı sarıcısı için basit bir bellek içi veritabanı olabilir.
• Bir saplama sadece bu testin gerekli işlemlerini yerine getirmek için gereken kadar uygular. Çoğu durumda, bir saplama bir teste veya yalnızca orijinal yöntemlerin küçük bir setini gerektiren bir test grubuna özgüdür. Bu örnekte, dataStoresadece insertUserRecord()ve 'nin uygun bir versiyonunu uygulayan olabilir recordIpAddress().
• Sahte, nasıl kullanıldığını doğrulamanıza izin veren bir nesnedir (çoğunlukla çağrıları yöntemlerine göre değerlendirmenize izin vererek). Bunları, ünite testlerinde çok az kullanmaya çalışırdım, çünkü onları kullanarak, aslında işlev uygulamasını test etmeye çalışırsınız, arayüzüne uyumu değil, ama yine de kullanımları vardır. İhtiyaç duyduğunuz sahtekarlığı yaratmanıza yardımcı olmak için pek çok sahte çerçeve vardır.

Bu yöntemlerden herhangi biri bir hata atarsa, hatanın uygun gördüğü şekliyle işleyebilmesi için çağrının koduna kabarmasını istiyoruz. API kodu tarafından çağrılıyorsa, hatayı uygun bir HTTP yanıt koduna çevirebilir. Bir web arayüzü tarafından aranıyorsa, hatayı kullanıcıya gösterilecek şekilde uygun bir mesaja çevirebilir. Mesele şu ki, bu fonksiyon atılabilecek hataları nasıl idare edeceğini bilmiyor.

Beklenen istisnalar / hatalar geçerli test durumlarıdır: Böyle bir olay olması durumunda, işlevin beklediğiniz gibi davrandığını onaylarsınız. Bu, ilgili sahte / sahte / saplama nesnesinin istendiğinde atmasını sağlayarak başarılabilir.

Kafamın özü, böyle bir işlevi test etmek için testin kendisinde tam olarak uygulamanın tekrarlanmasının gerekli göründüğüdür (yöntemlerin belli bir sıradaki alaylara çağrılmasıyla) ve bu yanlış görünüyor.

Bazen bu yapılmalı (entegrasyon testlerinde çoğunlukla bunu umursuyorsanız da). Daha sık, beklenen yan etkileri / durum değişikliklerini doğrulamanın başka yolları da vardır.

Tam işlev çağrılarının doğrulanması, oldukça kırılgan birim testlerinin yapılmasını sağlar: Orijinal işlevde yalnızca küçük değişiklikler yapılmamasına neden olur. Bu arzu edilebilir veya istenmeyebilir, ancak bir işlevi değiştirdiğinizde ilgili birim test (ler) inde bir değişiklik yapılması gerekir (yeniden düzenleme, optimizasyon, hata düzeltme, ...).

Ne yazık ki, bu durumda ünite testi bazı güvenilirliğini kaybeder: değiştiğinden, değişiklik eskisi gibi davrandıktan sonra işlevi onaylamaz.

Örneğin, oven.preheat()çerez pişirme örneğinizde (optimizasyon!) Bir arama ekleyen birini düşünün :

• Fırın nesnesini alay ettiyseniz, yöntemin gözlemlenebilir davranışı değişmediyse de denemenin başarısız olduğunu beklemez ve testin başarısız olmasını beklemez (umarım hala bir kurabiye tabağınız vardır).
• Bir saplama, yalnızca test edilecek yöntemleri veya tüm arayüzü bazı kukla yöntemlerle eklediğinize bağlı olarak başarısız olabilir veya olmayabilir.
• Sahte başarısız olmalı, çünkü yöntemi uygulamalıdır (arayüze göre)

Birim testlerimde mümkün olduğunca genel olmaya çalışıyorum: Uygulama değişirse, ancak görünen davranış (arayanın perspektifinden) hala aynıysa, testlerim geçmelidir. İdeal olarak, mevcut bir ünite testini değiştirmem gereken tek vaka bir hata düzeltmesi olmalıdır (testin değil, test edilen fonksiyonun).

Böyle bir testin sağladığı birincil değer, uygulamanızı yenilenebilir kılar.

Kariyerimde birçok performans optimizasyonu yapardım ve gösterdiğiniz modelle ilgili sık sık problemler yaşardım: N varlıklarını veritabanına kaydetmek, N ekleri yapmak. Tek bir deyim kullanarak toplu ekleme yapmak genellikle daha etkilidir.

Öte yandan, zamanından önce optimize etmek de istemiyoruz. Genellikle bir seferde yalnızca 1 - 3 kişiyi kurtarırsanız, optimize edilmiş bir toplu iş yazmak aşırı yüklenebilir.

Uygun bir birim testiyle, onu yukarıda uyguladığınız şekilde yazabilirsiniz ve en iyi duruma getirmeniz gerektiğini tespit ederseniz, herhangi bir hatayı yakalamak için otomatik bir testin güvenlik ağını kullanmakta özgürsünüz. Doğal olarak, bu testlerin kalitesine göre değişir, bu nedenle liberal olarak test edin ve iyi test edin.

Bu davranışı test eden birimin ikincil avantajı, amacının ne olduğuna dair dokümantasyon sağlamaktır. Bu önemsiz örnek açık olabilir, ancak aşağıdaki bir sonraki noktaya bakıldığında, çok önemli olabilir.

Diğerlerinin de belirttiği üçüncü avantaj, entegrasyon veya kabul testleriyle test etmek çok zor olan detayları kapsayan testleri test edebilmenizdir. Örneğin, tüm kullanıcıların atomik olarak kaydedilmesi gerekliliği varsa, bunun için bir test durumu yazabilirsiniz, bu size beklendiği gibi davrandığını bilmenin bir yolunu sunar ve ayrıca açıkça görülmeyen bir gereksinim için dokümantasyon görevi görür. yeni geliştiricilere.

TDD eğitmeninden aldığım bir düşünceyi ekleyeceğim. Yöntemi test etme. Davranışı test et. Başka bir deyişle, bunun savePeopleişe yaradığını test etmiyorsunuz, birden fazla kullanıcının tek bir çağrıya kaydedilebileceğini test ediyorsunuz.

Bir programın çalıştığını doğrulamak gibi ünite testlerini düşünmeyi bıraktığımda kalite birimi testini ve TDD'yi iyileştirme yeteneğimi buldum, ancak bunun yerine bir kod biriminin beklediğim şeyi yaptığını doğruladılar . Bunlar farklı. Çalıştığını doğrulamıyorlar, ama düşündüğüm şeyi yaptığını doğruladılar. Bu şekilde düşünmeye başladığımda bakış açım değişti.

Meli bakeCookies()test edilecek? Evet.

Bunun gibi bir fonksiyon, olması gerektiğini düşündüğünüz varsayılarak, nasıl test edilmeli? Hamur, tava ve fırınla ​​alay etmeyen herhangi bir birim testini hayal etmem ve daha sonra kendilerine metotların çağrıldığını iddia etmek zor.

Pek sayılmaz. Fonksiyonun NE yapması gerektiğine yakından bakın - ovennesneyi belirli bir duruma getirmesi gerekiyordu . Koda bakıldığında, nesnelerin panve doughnesnelerin durumlarının gerçekten önemli olmadığı anlaşılıyor . Öyleyse bir ovennesneyi geçmeli (veya alay etmeli ) ve işlev çağrısının sonunda belirli bir durumda olduğunu iddia etmelisiniz .

Başka bir deyişle, kurabiyeleri pişirdiğini iddia etmelisinizbakeCookies() .

Çok kısa fonksiyonlar için birim testleri totolojiden biraz daha fazla görünebilir. Ama unutma, programın, yazarken çalıştığın zamandan çok daha uzun sürecek. Bu işlev gelecekte değişebilir veya değişmeyebilir.

Birim testleri iki işleve sahiptir:

1. Her şeyin çalıştığını test ediyor. Bu, en az kullanışlı fonksiyon biriminin test ettiği ve soruyu sorarken yalnızca bu işlevi düşündüğünüz görülüyor.

2. Programın gelecekteki değişikliklerinin daha önce uygulanmış olan işlevselliği bozmadığını kontrol eder. Bu, birim testlerinin en faydalı işlevidir ve hataların büyük programlara girmesini önler. Programa özellikler eklerken normal kodlamada kullanışlıdır, ancak programı uygulayan temel algoritmaların programın gözlemlenebilir herhangi bir davranışını değiştirmeden büyük ölçüde değiştirildiği yeniden düzenleme ve optimizasyonlarda daha kullanışlıdır.

İşlev içindeki kodu test etmeyin. Bunun yerine, fonksiyonun söylediğini yaptığını test edin. Ünite sınamalarına bu şekilde baktığınızda (sınama işlevleri, kod değil), dil yapılarını veya uygulama mantığını hiçbir zaman sınamadığınızı fark edersiniz. Bir API'yi test ediyorsunuz.

SavePeople () birim testine tabi tutulmalı mı yoksa bu tür testler forEach dil yapısını test etmeyi mi gerektiriyor?

Evet. Ama olabilir sadece yapısını yeniden test edecek bir şekilde yapıyoruz.

Burada dikkat edilmesi gereken, savePersonyarı yolda başarısız olduğunda bu fonksiyonun nasıl davrandığıdır ? Nasıl çalışması gerekiyor?

Bu , fonksiyonun birim sınamalarında uygulamanız gerektiğini sağladığı ince davranış türüdür.

Burada anahtar önemsiz olarak belirli bir fonksiyona bakış açınız. Programlamanın çoğu önemsizdir: bir değer atayın, biraz matematik yapın, bir karar verin: eğer öyleyse, o zamana kadar bir döngü devam edin ... İzolasyonda, hepsi önemsiz. Bir programlama dilini öğreten herhangi bir kitabın ilk 5 bölümünü yeni aldınız.

Bir test yazmanın çok kolay olması, tasarımınızın o kadar da kötü olmadığının bir işareti olmalıdır. Test edilmesi kolay olmayan bir tasarımı tercih eder misiniz?

“Bu asla değişmeyecek.” çoğu başarısız projenin nasıl başladığı. Bir birim testi, yalnızca ünitenin belirli koşullar altında beklendiği gibi çalışıp çalışmadığını belirler. Geçmesini sağlayın ve ardından uygulama ayrıntılarını unutabilir ve sadece kullanabilirsiniz. Bir sonraki görev için o beyin alanını kullanın.

İşlerin beklendiği gibi çalıştığını bilmek çok büyük ve büyük projelerde ve özellikle de büyük ekiplerde önemsiz değildir. Programcıların ortak noktalarından biri varsa, hepimizin başkasının korkunç koduyla uğraşmak zorunda olduğumuz gerçeğidir. En azından yapabileceğimiz bazı testler var. Şüphe duyduğunuzda, bir test yazın ve devam edin.

SavePeople () birim testine tabi tutulmalı mı yoksa bu tür testler forEach dil yapısını test etmeyi mi gerektiriyor?

Bu, @BryanOakley tarafından zaten cevaplandı, ancak bazı ekstra argümanlarım var (Sanırım):

İlk olarak, bir birim testi, bir API'nın uygulanmasının değil, bir sözleşmenin yerine getirilmesinin test edilmesi içindir; Test ön koşulları belirlemeli, sonra aramalı, sonra efektleri, yan etkileri, değişmeyenleri ve postalama koşullarını kontrol etmelidir. Neyin test edileceğine karar verdiğinizde , API'nin uygulanması önemli değildir (ve olmamalıdır) .

İkinci olarak, testiniz işlev değiştiğinde değişmezleri kontrol etmek için orada olacaktır . Şimdi değişmemesi gerçeği , sınava girmemeniz gerektiği anlamına gelmiyor.

Üçüncüsü, hem TDD yaklaşımında (onu zorunlu kılan) hem de bunun dışında önemsiz bir test uygulamanın değeri var.

C ++ yazarken, sınıflarım için, bir nesneyi başlatan ve değişmezleri kontrol eden önemsiz bir test yazma eğilimindeyim (atanabilir, normal, vb.). Geliştirme sırasında bu testin kaç kez kırılmasının şaşırtıcı olduğunu buldum (örneğin - bir sınıfa hareketli olmayan bir üye ekleyerek).

Bence sorunuz aşağı düşüyor:

Bir boşluk fonksiyonunu bir entegrasyon testi olmadan nasıl test edebilirim?

Çerez pişirme işlevinizi değiştirirsek, örneğin çerezleri geri gönderirsek, örneğin testin ne olması gerektiği hemen belli olur.

Fonksiyonu çağırdıktan sonra pan.GetCookies'i çağırmak zorunda kalırsak, 'gerçekten bir entegrasyon testi' mi yoksa 'sadece pan nesnesini mi test ettiğimizi' sorabilir miyiz?

Bence her şeyle alay etmiş bir ünite testi yaptırmakta haklısın ve sadece kontrol fonksiyonlarına xy ve z'nin değer eksikliği deniyorsun.

Fakat! Bu durumda test edilebilir bir sonuç döndürmek için boş fonksiyonlarınızı yeniden kırmanız gerektiğini VEYA gerçek nesneleri kullanıp bir entegrasyon testi yaptırmanız gerektiğini savunuyorum.

--- createNewUser örneği için güncelleme

• veritabanında yeni bir kullanıcı kaydı oluşturulması gerekiyor
• hoş bir e-posta gönderilmesi gerekiyor
• kullanıcının IP adresinin dolandırıcılık amacıyla kaydedilmesi gerekir.

Tamam, bu kez fonksiyonun sonucu kolayca döndürülemez. Parametrelerin durumunu değiştirmek istiyoruz.

Burası biraz tartışmalı olduğum yer. Durumsal parametreler için somut sahte uygulamalar yaratıyorum

Lütfen sevgili okuyucular, öfkenizi kontrol etmeye çalışın!

yani...

var validatedUserData = new UserData(); //we can use the real object for this
var emailService = new MockEmailService(); //a simple mock which saves sentEmails to a List<string>
var dataStore = new MockDataStore(); //a simple mock which saves ips to a List<string>

//run the test
target.createNewUser(validatedUserData, emailService, dataStore);

//check the results
Assert.AreEqual(1, emailService.EmailsSent.Count());
Assert.AreEqual(1, dataStore.IpsRecorded.Count());
Assert.AreEqual(1, dataStore.UsersSaved.Count());

Bu, test edilen yöntemin uygulama detayını istenen davranıştan ayırır. Alternatif bir uygulama:

function createNewUser(validatedUserData, emailService, dataStore) {
  userId = dataStore.bulkInsedrtUserRecords(new [] {validateduserData});
  emailService.addEmailToQueue(validatedUserData);
  emailService.ProcessQueue();
  dataStore.recordIpAddress(userId, validatedUserData.ip);
}

Hala ünite testinden geçecek. Ayrıca, sahte nesneleri testler arasında yeniden kullanabilme ve UI veya Entegrasyon Testleri için uygulamanıza enjekte etme avantajına sahipsiniz.

Ayrıca test etmelisiniz bakeCookies- ne vermeli / vermeli bakeCookies(egg, pan, oven)? Kızarmış yumurta mı, istisna mı? Kendi başlarına, asıl malzemeleri ne panumursarlar ne de ovenumursarlar, çünkü hiçbiri bakeCookiesyapmamalı , fakat genellikle çerezler vermelidir. Daha genel olarak nasıl bağlı olabilir doughelde edilir ve orada olmadığını ise o sadece olma şansı eggveya örneğin wateryerine.