Üniteyi test etmek için özel bir yöntemi herkese açık hale getirmek… iyi fikir mi?

_{Moderatör Not: Burada zaten 39 cevap gönderildi (bazıları silindi). Eğer göndermeden önce senin cevabını, tartışmanın anlamlı bir şey eklemek mümkün olup olmadığını düşünün. Muhtemelen başka birinin söylediklerini tekrar ediyorsunuz.}

Bazen kendimi sadece bazı birim testleri yazmak için bir sınıfta özel bir yöntem yapmaya ihtiyaç duyuyorum.

Genellikle bu yöntem sınıftaki diğer yöntemler arasında paylaşılan mantık içerdiğinden ve mantığı kendi kendine test etmek için daha düzenli olduğundan veya senkronize dişlerde kullanılan mantığı diş açma problemleri hakkında endişelenmeden test etmek isteyebileceğimden dolayı olabilir. .

Diğer insanlar bunu yaparken buluyorlar mı, çünkü gerçekten yapmaktan hoşlanmıyorum ?? Şahsen ikramiyelerin, sınıf dışında gerçekten herhangi bir hizmet sağlamayan bir yöntemi halka açık hale getirme sorunlarından daha ağır bastığını düşünüyorum ...

GÜNCELLEME

Herkese cevaplar için teşekkürler, insanların ilgisini çekmiş gibi görünüyor. Bence genel fikir birliği, bir sınıfın kullanılabileceği tek yol olduğu için testin genel API aracılığıyla yapılması gerektiğini düşünüyorum ve bunu kabul ediyorum. Yukarıda bunu yapacağım yukarıda bahsettiğim birkaç vaka nadirdi ve bunu yapmanın yararlarının buna değdiğini düşündüm.

Ancak herkesin bunun gerçekten olmaması gerektiğini gösterdiğini görebiliyorum. Ve biraz daha düşündüğümde, testlere uyum sağlamak için kodunuzu değiştirmenin kötü bir fikir olduğunu düşünüyorum - sonuçta testin bir şekilde bir destek aracı olduğunu ve eğer isterseniz bir destek aracını destekleyecek bir sistemi değiştirmenin açık olduğunu düşünüyorum. kötü uygulama.

Not:
Bu yanıt aslen soru testi için gönderilmiştir Ünite testi tek başına özel örnek değişkenleri alıcılar aracılığıyla ortaya çıkarmak için iyi bir neden midir? Bu birleştirilmiş, bu yüzden orada sunulan usecase biraz özel olabilir.

Genel bir açıklama olarak, ben genellikle "üretim" kodu yeniden test için kolaylaştırmak için yeniden. Ancak, bunun iyi bir çağrı olacağını düşünmüyorum. İyi bir birim testi (genellikle), sınıfın uygulama ayrıntılarını değil, yalnızca görünür davranışını dikkate almalıdır. Bunun yerine testine iç yığınlar ortaya çıkarmak gibi, sınıf aradığınız sonra bunu bekliyoruz sırayla sayfaları döndüren test edebilir first()ya last().

Örneğin, şu sahte kodu düşünün:

public class NavigationTest {
    private Navigation nav;

    @Before
    public void setUp() {
        // Set up nav so the order is page1->page2->page3 and
        // we've moved back to page2
        nav = ...;
    }

    @Test
    public void testFirst() {
        nav.first();

        assertEquals("page1", nav.getPage());

        nav.next();
        assertEquals("page2", nav.getPage());

        nav.next();
        assertEquals("page3", nav.getPage());
    }

    @Test
    public void testLast() {
        nav.last();

        assertEquals("page3", nav.getPage());

        nav.previous();
        assertEquals("page2", nav.getPage());

        nav.previous();
        assertEquals("page1", nav.getPage());
    }
}

Şahsen, kamu API kullanarak yerine birim testi olur ve kesinlikle özel yöntem herkese açık hale asla sadece testin kolay yapmak.

Özel yöntemi gerçekten ayrı olarak test etmek istiyorsanız, Java'da bunu yapmanıza izin vermek için Easymock / Powermock kullanabilirsiniz .

Bu konuda pragmatik olmalısınız ve ayrıca işlerin test edilmesinin zor olmasının nedenlerinin de farkında olmalısınız.

' Testleri dinleyin ' - eğer test etmek zorsa, bu size tasarımınız hakkında bir şey mi söylüyor? Bu yöntem için yapılan bir testin kamuya açık API üzerinden test edilerek önemsiz ve kolay bir şekilde kapsanabileceği durumu yeniden değerlendirebilir misiniz?

İşte, Michael Tüyler 'söylemek zorunda olduğunu Etkili Legacy koduyla çalışma "

"Birçok kişi bu sorunun üstesinden nasıl geleceğini bulmak için çok zaman harcıyor ... asıl cevap, özel bir yöntemi test etme isteğiniz varsa, yöntemin özel olmaması gerekir; eğer yöntemi herkese açık hale getirirseniz seni rahatsız ediyor, şansı, bunun nedeni ayrı bir sorumluluğun parçası olması; başka bir sınıfta olması. " [ Eski Yasalarla Etkili Çalışma (2005) M. Feathers]

Diğerlerinin söylediği gibi, özel yöntemleri hiç bir şekilde birim test etmek şüphelidir; birim özel uygulama ayrıntılarını değil, genel arayüzü test eder.

Bununla birlikte, C # 'da özel bir şeyi test etmek istediğimde kullandığım teknik, erişilebilirlik korumasını özelden iç kısma düşürmek ve daha sonra InternalsVisibleTo kullanarak bir birim montajı olarak işaretlemektir . Daha sonra birim test düzeneğinin iç kısımları halka açık olarak ele almasına izin verilir, ancak yanlışlıkla kamu yüzey alanınıza ekleme konusunda endişelenmenize gerek yoktur.

Birçok yanıt yalnızca ortak arabirimi test etmeyi önerir, ancak IMHO bu gerçekçi değildir - bir yöntem 5 adım süren bir şey yaparsa, bu beş adımı ayrı ayrı test etmek isteyeceksiniz, hep birlikte değil. Bu, aksi takdirde (test dışında) olabilecek beş yöntemin tümünü de test etmeyi gerektirir private.

"Özel" yöntemleri test etmenin olağan yolu, her sınıfa kendi arayüzünü vermek ve "özel" yöntemleri yapmak public, ancak bunları arayüze dahil etmektir. Bu şekilde, hala test edilebilirler, ancak arayüzü şişirmezler.

Evet, bu dosya ve sınıf bloatlarına neden olur.

Evet, bu publicve privatebelirteçleri gereksiz kılar .

Evet, bu kıçta bir acı.

Ne yazık ki, kodu test edilebilir yapmak için yaptığımız birçok fedakarlıktan biri budur . Belki de gelecekteki bir dil (veya C # / Java'nın gelecekteki bir sürümü) sınıf ve modül test edilebilirliğini daha kolay hale getirecek özelliklere sahip olacaktır; ama bu arada, bu çemberlerden atlamak zorundayız.

Bu adımların her birinin kendi sınıfı olması gerektiğini iddia eden bazıları var , ama katılmıyorum - eğer hepsi devlet paylaşıyorsa, beş yöntemin yapacağı beş ayrı sınıf oluşturmak için bir neden yoktur. Daha da kötüsü, bu dosya ve sınıf-bloat ile sonuçlanır. Ayrıca , modülünüzün genel API'sına da bulaşır - publicbunları başka bir modülden test etmek istiyorsanız mutlaka tüm bu sınıflar olmalıdır (ya da test kodunu aynı modüle dahil edin, yani test kodunu ürününüzle birlikte gönderin) .

Bir birim testi, bir sınıfın kodun diğer bölümlerinde nasıl kullanılabileceğini tek şekilde kamu sözleşmesini test etmelidir. Özel bir yöntem uygulama ayrıntılarıdır, herkese açık API doğru çalıştığı sürece uygulama önemli değildir ve test senaryolarında değişiklik yapılmadan değiştirilebilir.

IMO, testlerinizi, sınıfınızın içeride nasıl uygulandığına dair derin varsayımlar yapmadan yazmalısınız. Muhtemelen daha sonra başka bir dahili model kullanarak yeniden düzenleme yapmak istiyorsunuz, ancak yine de önceki uygulamanın verdiği garantileri aynen yapıyorsunuz.

Bunu akılda tutarak, sınıfınızda şu anda hangi dahili uygulamaya sahip olursanız olun sözleşmenizin hala geçerli olduğunu test etmeye odaklanmanızı öneririm. Herkese açık API'larınızın mülke dayalı testi.

Paketi özel yapmaya ne dersiniz? Daha sonra test kodunuz onu (ve paketinizdeki diğer sınıfları da) görebilir, ancak yine de kullanıcılarınızdan gizlidir.

Ama gerçekten, özel yöntemleri test etmemelisiniz. Bunlar uygulama detaylarıdır ve sözleşmenin bir parçası değildir. Yaptıkları her şey kamu yöntemlerini çağırarak ele alınmalıdır (orada kamu yöntemlerinin kullanmadığı bir kod varsa, o zaman gitmelidir). Özel kod çok karmaşıksa, sınıf muhtemelen çok fazla şey yapıyor ve yeniden düzenleme yapmak istiyor.

Bir yöntemi halka duyurmak büyük bir taahhüttür. Bunu yaptıktan sonra, insanlar bunu kullanabilir ve artık onları değiştiremezsiniz.

Güncelleme : Bu soruya başka birçok yerde daha geniş ve eksiksiz bir cevap ekledim. Bu blogumda bulunabilir .

Test etmek için bir şeyi herkese açık hale getirmem gerekirse, bu genellikle test edilen sistemin Tek Tekrarlanabilirlik İlkesine uymadığını ima eder . Dolayısıyla, tanıtılması gereken eksik bir sınıf vardır. Kodu yeni bir sınıfa çıkardıktan sonra herkese açık hale getirin. Şimdi kolayca test edebilirsiniz ve SRP'yi takip ediyorsunuz. Diğer sınıfınız sadece bu yeni sınıfı kompozisyonla çağırmak zorundadır.

Metodları herkese açık hale getirme / test montajları için görünür kod işaretleme gibi dil hilelerini kullanma her zaman son çare olmalıdır.

Örneğin:

public class SystemUnderTest
{
   public void DoStuff()
   {
      // Blah
      // Call Validate()
   }

   private void Validate()
   {
      // Several lines of complex code...
   }
}

Doğrulayıcı bir nesne ekleyerek bunu yeniden düzenleyin.

public class SystemUnderTest
{
    public void DoStuff()
    {
       // Blah
       validator.Invoke(..)
    }
}

Şimdi tek yapmamız gereken doğrulayıcının doğru şekilde çağrıldığını test etmektir. Gerçek doğrulama süreci (önceden özel mantık) saf izolasyonda test edilebilir. Bu doğrulamanın başarılı olmasını sağlamak için karmaşık test kurulumuna gerek kalmayacaktır.

Bazı harika cevaplar. Bahsetmediğim bir şey, test odaklı geliştirme (TDD) ile, yeniden düzenleme aşamasında özel yöntemlerin yaratıldığı ( yeniden düzenleme modelinin bir örneği için Ekstraksiyon Yöntemine bakın) ve bu nedenle zaten gerekli test kapsamına sahip olması gerektiğidir. . Doğru bir şekilde yapılırsa (ve elbette, doğruluk söz konusu olduğunda karışık bir fikir çantası alacaksınız), test edebilmeniz için özel bir yöntemi herkese açık hale getirme konusunda endişelenmenize gerek yoktur.

Neden yığın yönetimi algoritmasını bir yardımcı program sınıfına ayırmıyorsunuz? Hizmet sınıfı yığınları yönetebilir ve genel erişim sağlayabilir. Birim testleri uygulama detaylarına odaklanabilir. Algoritmik olarak zor sınıflar için derin testler, uç vakaların kırışmasında ve kapsamın sağlanmasında çok yardımcıdır.

Ardından, geçerli sınıfınız, uygulama ayrıntılarını göstermeden yardımcı program sınıfına temiz bir şekilde yetki verebilir. Testleri, diğerlerinin önerdiği gibi sayfalandırma gereksinimi ile ilgilidir.

Java'da, paketi özel yapma seçeneği de vardır (örn. Görünürlük değiştiricisini bırakma). Birim testleriniz test edilen sınıfla aynı pakette ise, bu yöntemleri görebilmeli ve yöntemi tamamen herkese açık hale getirmekten biraz daha güvenli olmalıdır.

Özel yöntemler genellikle "yardımcı" yöntemler olarak kullanılır. Bu nedenle, yalnızca temel değerleri döndürürler ve asla nesnelerin belirli örneklerinde çalışmazlar.

Test etmek istiyorsanız birkaç seçeneğiniz vardır.

• Yansımayı kullan
• Yöntem paketine erişim izni verin

Alternatif olarak, yeni bir sınıf için yeterince iyi bir aday ise, genel yöntem olarak yardımcı yöntemle yeni bir sınıf oluşturabilirsiniz.

Burada bu konuda çok iyi bir makale var .

C # kullanıyorsanız yöntemi dahili yapabilirsiniz. Bu şekilde herkese açık API'yı kirletmezsiniz.

Sonra dll'ye öznitelik ekleyin

[assembly: InternalsVisibleTo ("MyTestAssembly")]

Artık tüm yöntemler MyTestAssembly projenizde görülebilir. Belki mükemmel değil, ancak özel yöntemi sadece test etmek için herkese açık hale getirmek daha iyidir.

Gerekirse özel değişkenlere erişmek için yansımayı kullanın.

Ama gerçekten, sınıfın iç durumunu umursamıyorsunuz, sadece genel yöntemlerin tahmin edebileceğiniz durumlarda beklediğinizi geri getirdiğini test etmek istiyorsunuz.

Kötü bir fikir olduğunu söyleyebilirim, çünkü herhangi bir fayda ve potansiyel olarak sorun yaşamayacağınızdan emin değilim. Çağrıların sözleşmesini değiştiriyorsanız, sadece özel bir yöntemi test etmek için, sınıfı nasıl kullanılacağı konusunda test etmiyorsunuz, ancak asla gerçekleşmesini istemediğiniz yapay bir senaryo oluşturuyorsunuz.

Ayrıca, yöntemi herkese açık olarak ilan ederek, altı ay içinde (bir yöntemi herkese açık hale getirmenin tek sebebinin test etmek olduğunu unutduktan sonra) sizin (veya projeyi teslim ettiyseniz) tamamen farklı birinin potansiyel olarak istenmeyen sonuçlara ve / veya bakım kabusuna yol açmaz.

birim testi açısından, kesinlikle daha fazla yöntem eklememelisiniz; Her bir testten first()önce çağrılacak yönteminizle ilgili bir test durumu daha iyi yapacağınıza inanıyorum ; o zaman birden çok kez çağırabilir - next(), previous()ve last()sonuçları beklentilerinizi maç olmadığını görmek için. Sınıfınıza daha fazla yöntem eklemezseniz (sadece test amacıyla), "kara kutu" test prensibine bağlı kalacağınızı tahmin ediyorum;

Öncelikle yöntemin başka bir sınıfa çıkarılıp kamuya duyurulması gerekip gerekmediğine bakın. Durum böyle değilse, paketi korumalı hale getirin ve Java'da @VisibleForTesting ile açıklama ekleyin .

Güncellemenizde, herkese açık API'yı kullanarak test yapmanın iyi olduğunu söylüyorsunuz. Aslında burada iki okul var.

1. Kara kutu testi

   Kara kutu okulu, sınıfın kimsenin içindeki uygulamayı göremeyeceği bir kara kutu olarak düşünülmesi gerektiğini söylüyor. Bunu test etmenin tek yolu, tıpkı sınıf kullanıcısının kullanacağı gibi, herkese açık API yoluyladır.

2. beyaz kutu testi.

   Beyaz kutu okulu, doğal olarak, sınıfın uygulanması hakkındaki bilgileri kullanmayı ve daha sonra sınıfın gerektiği gibi çalıştığını bilmek için test etmeyi düşünüyor.

Tartışmaya gerçekten katılamıyorum. Sadece bir sınıfı (ya da bir kütüphaneyi ya da her neyse) test etmenin iki farklı yolu olduğunu bilmenin ilginç olacağını düşündüm.

Aslında bunu yapmanız gereken durumlar vardır (örneğin bazı karmaşık algoritmalar uygularken). Sadece paket özel yapın ve bu yeterli olacaktır. Ancak çoğu durumda, muhtemelen diğer sınıflara mantığı çarpanlarına ayırmayı gerektiren çok karmaşık sınıflarınız vardır.

Tek başına test etmek istediğiniz özel yöntemler, sınıfınızda gömülü başka bir "kavram" olduğunun bir göstergesidir. Bu "konsepti" kendi sınıfına çıkarın ve ayrı bir "birim" olarak test edin.

Konuya gerçekten ilginç bir bakış için bu videoya bir göz atın .

Testlerinizin kodunuzu dikte etmesine asla izin vermemelisiniz. TDD veya diğer DD'lerden bahsetmiyorum, tam olarak ne istediğini. Uygulamanızın herkese açık olması için bu yöntemlere ihtiyacı var mı? Eğer öyleyse onları test edin. Eğer yapmazsa, sadece test için onları halka açmayın. Değişkenler ve diğerleri ile aynı. Uygulamanızın ihtiyaçlarının kodu dikte etmesine izin verin ve testlerinizin ihtiyacın karşılandığını test etmesine izin verin. (Yine ilk olarak test etmek demek istemiyorum ya da değil, test amacına ulaşmak için bir sınıf yapısını değiştirmek demek istiyorum).

Bunun yerine "daha yüksek test yapmalısınız". Özel yöntemi çağıran yöntemi test edin. Ancak testleriniz "uygulama kararlarınızı" değil, uygulama ihtiyaçlarınızı test ediyor olmalıdır.

Örneğin (bod sözde kodu burada);

   public int books(int a) {
     return add(a, 2);
   }
   private int add(int a, int b) {
     return a+b;
   } 

Bunun yerine "kitaplar" ı test etmek için "ekle" yi test etmek için bir neden yoktur.

Testlerinizin sizin için kod tasarımı kararları vermesine asla izin vermeyin. Bu sonucu nasıl alacağınızı değil, beklenen sonucu elde ettiğinizi test edin.

Birimi test ettirme bonuslarının, bazı üyelerin görünürlüğünü artırma sorunlarından daha ağır bastığı konusunda hemfikirim. Küçük bir gelişme, korumalı ve sanal hale getirmektir, daha sonra ortaya çıkarmak için bir test sınıfında geçersiz kılınır.

Alternatif olarak, ayrı ayrı test etmek istediğiniz işlevsellik varsa, tasarımınızda eksik bir nesne bulunmuyor mu? Belki onu ayrı bir test edilebilir sınıfa koyabilirsiniz ... o zaman mevcut sınıfınız bu yeni sınıfın bir örneğine yetki verir.

Test sınıflarını genellikle test edilen sınıflarla aynı proje / montajda tutarım.
Bu şekilde sadece ihtiyacım varinternal fonksiyonları / sınıfları test edilebilir kılmak için görünürlüğe .

Bu, test sınıflarını filtrelemesi gereken yapım sürecinizi biraz karmaşıklaştırır. Bunu tüm test sınıflarımı isimlendirerek TestedClassTestve bu sınıfları filtrelemek için bir normal ifade kullanarak başarıyorum.

Bu elbette sorunuzun C # / .NET kısmı için geçerlidir

Sık sık bir şeyler gibi adlı bir yöntem katacak validate, verify,check bir nesnenin iç durumu test etmek için çağrılabilir, böylece bir sınıfa, vb.

Bazen bu yöntem bir ifdef bloğuna sarılır (çoğunlukla C ++ ile yazılır), böylece serbest bırakılması için derlenmez. Ancak, çoğu zaman, programın nesne ağaçlarını bir şeyleri kontrol ederek yürütebilen doğrulama yöntemleri sağlamak için genellikle faydalıdır.

Guava, aksi takdirde yapacakları kapsamı (paket veya genel) olan işaretleme yöntemleri için @VisibleForTesting ek açıklamasına sahiptir. Aynı şey için @Gizli ek açıklama kullanıyorum.

Herkese açık API'nın test edilmesi gerekirken, normalde herkese açık olmayacak şeylere ulaşmak bazen uygun ve mantıklıdır.

Ne zaman:

• bir sınıf, birden fazla sınıfa ayrılarak, daha az okunabilir hale getirilir,
• sadece daha test edilebilir hale getirmek için,
• ve innards için biraz test erişimi sağlamak hile yapardı

din mühendisliği yıkıyor gibi görünüyor.

Genellikle bu yöntemleri bırakıyorum protectedve sınıf yükleyicisi onları aynı ad alanına yerleştireceğinden, korunan tüm yöntemlere erişebilecekleri aynı paketin (ancak başka bir proje veya kaynak klasöründe) birim testini yerleştiriyorum.

Hayır, çünkü o kediyi daha iyi ciltlemenin yolları var.

Bazı birim test kayışları, sınıf tanımında, test modundayken kanca oluşturmak için otomatik olarak genişleyen makrolara dayanır. Çok C tarzı, ama işe yarıyor.

Daha kolay bir OO deyimi "özel" yerine "korumalı" test etmek istediğiniz her şeyi yapmaktır. Test koşum takımı test edilen sınıftan miras alır ve daha sonra tüm korunan üyelere erişebilir.

Ya da "arkadaş" seçeneğini tercih edersiniz. Şahsen bu en az C ++ kapsülleme kurallarını ihlal çünkü özelliği, ama C ++ bazı özellikleri nasıl uyguladığı için gerekli olur, bu yüzden hey ho.

Her neyse, birim testi yapıyorsanız, o üyelere değer enjekte etme olasılığınız yüksektir. Beyaz kutu manifatura mükemmel bir şekilde geçerlidir. Ve bu gerçekten olur senin kapsülleme bölünürler.

Net'te özel bir sınıf var. PrivateObjectNet'te, bir sınıfın özel yöntemlerine erişmenizi sağlamak için özellikle tenezzül özel bir sınıf vardır.

Bununla ilgili daha fazla bilgiyi MSDN'de veya burada Stack Overflow'da görebilirsiniz

(Şimdiye kadar kimsenin bundan bahsetmediğini merak ediyorum.)

Ancak bunun yeterli olmadığı durumlar vardır, bu durumda yansıma kullanmak zorunda kalacaksınız.

Yine de özel yöntemleri test etmemek için genel öneriye uyuyorum, ancak her zamanki gibi her zaman istisnalar var.

Diğerlerinin yorumları tarafından kapsamlı bir şekilde belirtildiği gibi, birim testleri genel API'ya odaklanmalıdır. Ancak, artıları / eksileri ve gerekçesi bir yana, yansıma kullanarak bir birim testte özel yöntemleri çağırabilirsiniz. Elbette JRE güvenliğinizin izin verdiğinden emin olmanız gerekir. Özel yöntemler çağırmak, Spring Framework'ün ReflectionUtils ile kullandığı bir şeydir ( makeAccessible(Method)yönteme bakın ).

Özel örnek yöntemine sahip küçük bir örnek sınıf.

public class A {
    private void doSomething() {
        System.out.println("Doing something private.");
    }
}

Özel örnek yöntemini yürüten bir örnek sınıf.

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class B {
    public static final void main(final String[] args) {
        try {
            Method doSomething = A.class.getDeclaredMethod("doSomething");
            A o = new A();
            //o.doSomething(); // Compile-time error!
            doSomething.setAccessible(true); // If this is not done, you get an IllegalAccessException!
            doSomething.invoke(o);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        }
    }
}

B yürütülmesi, yazdırılacak Doing something private. Gerçekten ihtiyacınız varsa, yansıma özel örnek yöntemlerine erişmek için birim testlerinde kullanılabilir.

Şahsen, özel yöntemleri test ederken aynı sorunları yaşıyorum ve bunun nedeni bazı test araçlarının sınırlı olması. İhtiyacınıza cevap vermezlerse tasarımınızı değil, aracı değiştirerek tasarımınızın sınırlı araçlarla sürülmesi iyi değildir. Çünkü C # istemeniz iyi test araçları öneremiyorum, ancak Java için iki güçlü araç var: TestNG ve PowerMock ve .NET platformu için ilgili test araçlarını bulabilirsiniz