Mockito kullanarak özel yöntemi test etme

public class A {

    public void method (boolean b) {
          eğer (b == doğru)
               Yöntem 1();
          Başka
               method2 ();
    }

    özel void yöntemi1 () {}
    özel void yöntemi2 () {}
}

public class TestA {

    @Ölçek
    public void testMethod () {
      A a = sahte (A. sınıf);
      a.method (doğru);
      // valid (a) .method1 () gibi nasıl test edilir;
    }
}

Özel yöntem nasıl test edilir veya çağrılmaz ve özel yöntem mockito kullanılarak nasıl test edilir ???

Bunu Mockito ile yapamazsınız, ancak Mockito'yu genişletmek ve özel yöntemleri taklit etmek için Powermock'u kullanabilirsiniz . Powermock, Mockito'yu destekler. İşte bir örnek.

Mockito ile mümkün değil. Onların itibaren wiki

Mockito neden özel yöntemlerle dalga geçmiyor?

Birincisi, özel yöntemlerle alay etme konusunda dogmatik değiliz. Özel yöntemleri umursamıyoruz çünkü özel yöntemleri test etme açısından mevcut değil. Mockito'nun özel yöntemlerle dalga geçmemesinin birkaç nedeni:

Asla kurşun geçirmez olmayan sınıf yükleyicilerin hacklenmesini gerektirir ve api'yi değiştirir (özel test çalıştırıcısı kullanmalı, sınıfa açıklama eklemelisiniz, vb.).

Etrafında çalışmak çok kolaydır - sadece yöntemin görünürlüğünü özelden paket korumalı (veya korumalı) olarak değiştirin.

Bunu uygulamak ve sürdürmek için zaman harcamamı gerektiriyor. Ve 2. maddede ve farklı bir araçta (powermock) halihazırda uygulanmış olması gerçeği verildiğinde bir anlam ifade etmiyor.

Son olarak ... Özel yöntemlerle dalga geçmek, OO anlayışında bir sorun olduğuna dair bir ipucudur. OO'da yöntemlerin değil, nesnelerin (veya rollerin) işbirliği yapmasını istersiniz. Pascal ve prosedürel kodu unutun. Nesnelerde düşünün.

İşte powermock ile nasıl yapılacağına dair küçük bir örnek

public class Hello {
    private Hello obj;
    private Integer method1(Long id) {
        return id + 10;
    }
} 

Yöntem 1'i test etmek için kodu kullanın:

Hello testObj = new Hello();
Integer result = Whitebox.invokeMethod(testObj, "method1", new Long(10L));

Özel nesne ayarlamak için obj bunu kullanın:

Hello testObj = new Hello();
Hello newObject = new Hello();
Whitebox.setInternalState(testObj, "obj", newObject);

Bunu hangi yöntemlerin olduğu ile değil, davranış açısından düşünün. Doğruysa çağrılan yöntemin methodbelirli bir davranışı vardır b. bYanlış ise farklı davranışı vardır . Bu, için iki farklı test yazmanız gerektiği anlamına gelir method; her durum için bir tane. Dolayısıyla, yönteme yönelik üç test yapmak yerine (biri için method, biri için method1, biri içinmethod2 , iki davranış odaklı testiniz var.

Bununla ilgili olarak (bunu yakın zamanda başka bir SO başlığında önerdim ve sonuç olarak dört harfli bir kelime olarak adlandırıldım, bu yüzden bunu bir tuz tanesi ile almaktan çekinmeyin); Yöntemin adı yerine test ettiğim davranışı yansıtan test adlarını seçmeyi faydalı buluyorum. Yani testleri demiyorlar testMethod(), testMethod1(), testMethod2()benzeri ve. Hangi davranışı test ettiğimi gösteren calculatedPriceIsBasePricePlusTax()veya gibi isimleri severim taxIsExcludedWhenExcludeIsTrue(); daha sonra her test yönteminde yalnızca belirtilen davranışı test edin. Bu tür davranışların çoğu, genel bir yönteme yalnızca bir çağrı içerecektir, ancak özel yöntemlere yapılan birçok çağrı içerebilir.

Bu yardımcı olur umarım.

Mockito bu özelliği sağlamazken, Mockito + JUnit ReflectionUtils sınıfını veya Spring ReflectionTestUtils sınıfını kullanarak aynı sonucu elde edebilirsiniz . Lütfen buradan özel bir yöntemin nasıl çağrılacağını açıklayan bir örneğe bakın :

ReflectionTestUtils.invokeMethod(student, "saveOrUpdate", "From Unit test");

ReflectionTestUtils ve Mockito ile eksiksiz örnekler, Mockito for Spring kitabında bulunabilir.

Özel yöntemleri test etmemelisiniz. Her halükarda özel yöntemleri çağırması gerektiğinden, yalnızca özel olmayan yöntemlerin test edilmesi gerekir. Özel yöntemleri test etmek "istiyorsanız", tasarımınızı yeniden düşünmeniz gerektiğini gösterebilir:

Uygun bağımlılık enjeksiyonu mu kullanıyorum? Özel yöntemleri ayrı bir sınıfa taşımam ve bunu test etmem gerekiyor mu? Bu yöntemler özel olmalı mı? ... varsayılan veya korumalı olamazlar mı?

Yukarıdaki örnekte, "rastgele" olarak adlandırılan iki yöntemin aslında kendi sınıflarına yerleştirilmesi, test edilmesi ve ardından yukarıdaki sınıfa enjekte edilmesi gerekebilir.

1. Yansıma kullanılarak, özel yöntemler test sınıflarından çağrılabilir. Bu durumda,

   // test yöntemi şöyle olacak ...

   public class TestA {
   
     @Test
       public void testMethod() {
   
       A a= new A();
       Method privateMethod = A.class.getDeclaredMethod("method1", null);
       privateMethod.setAccessible(true);
       // invoke the private method for test
       privateMethod.invoke(A, null);
   
       }
   }

2. Özel yöntem başka bir özel yöntemi çağırırsa, nesneyi gözetlememiz ve başka bir yöntemi saplamamız gerekir. Test sınıfı ...

   // test yöntemi şöyle olacak ...

   public class TestA {
   
     @Test
       public void testMethod() {
   
       A a= new A();
       A spyA = spy(a);
       Method privateMethod = A.class.getDeclaredMethod("method1", null);
       privateMethod.setAccessible(true);
       doReturn("Test").when(spyA, "method2"); // if private method2 is returning string data
       // invoke the private method for test
       privateMethod.invoke(spyA , null);
   
       }
   }

** Yaklaşım, yansıtma ve nesneyi gözetlemeyi birleştirmektir. ** yöntem1 ve ** yöntem2, özel yöntemler ve yöntem1 çağrıları yöntem2'dir.

Yansımayı kullanarak mockito kullanarak içeride özel bir yöntemi test edebildim. İşte örnek, mantıklı olacak şekilde adlandırmaya çalıştı

//Service containing the mock method is injected with mockObjects

@InjectMocks
private ServiceContainingPrivateMethod serviceContainingPrivateMethod;

//Using reflection to change accessibility of the private method

Class<?>[] params = new Class<?>[]{PrivateMethodParameterOne.class, PrivateMethodParameterTwo.class};
    Method m = serviceContainingPrivateMethod .getClass().getDeclaredMethod("privateMethod", params);
    //making private method accessible
    m.setAccessible(true); 
    assertNotNull(m.invoke(serviceContainingPrivateMethod, privateMethodParameterOne, privateMethodParameterTwo).equals(null));

Özel yöntemi test etme ihtiyacını gerçekten anlamıyorum. Temel sorun, genel yönteminizin dönüş türü olarak geçersiz olmasıdır ve bu nedenle genel yönteminizi test edemezsiniz. Bu nedenle özel yönteminizi test etmek zorunda kalıyorsunuz. Benim tahminim doğru mu?

Birkaç olası çözüm (AFAIK):

1. Özel yöntemlerinizle dalga geçiyorsunuz, ancak yine de yöntemlerinizi "gerçekten" test etmeyeceksiniz.

2. Yöntemde kullanılan nesnenin durumunu doğrulayın. ÇOĞUYLA yöntemler, giriş değerlerinin bazı işlemlerini gerçekleştirir ve bir çıktı döndürür veya nesnelerin durumunu değiştirir. Nesnelerin istenen durum için test edilmesi de kullanılabilir.

   public class A{
   
   SomeClass classObj = null;
   
   public void publicMethod(){
      privateMethod();
   }
   
   private void privateMethod(){
        classObj = new SomeClass();
   }
   
   }

   [Burada, classObj'nin null'dan null değil'e durum değişikliğini kontrol ederek özel yöntemi test edebilirsiniz.]

3. Kodunuzu biraz yeniden düzenleyin (umarız bu eski bir kod değildir). Bir yöntem yazmanın temel mantığı, bir kişinin her zaman bir şeyi (a int / a boolean) döndürmesidir. Döndürülen değer, uygulama tarafından KULLANILMAMAKTADIR veya OLMAYABİLİR, ancak test tarafından KESİNLİKLE kullanılacaktır

   kodu.

   public class A
   { 
       public int method(boolean b)
       {
             int nReturn = 0;
             if (b == true)
                  nReturn = method1();
             else
                  nReturn = method2();
       }
   
       private int method1() {}
   
       private int method2() {}
   
   }

Mockito ile özel bir üyeden yöntemleri test etmenin bir yolu var. Diyelim ki böyle bir sınıfınız var:

public class A {
    private SomeOtherClass someOtherClass;
    A() {
        someOtherClass = new SomeOtherClass();
    }
    public void method(boolean b){
        if (b == true)
            someOtherClass.method1();
        else
            someOtherClass.method2();
    }

}

public class SomeOtherClass {
    public void method1() {}
    public void method2() {}
}

a.methodDenemek istiyorsanız bir yöntem çağıracaktır SomeOtherClass, aşağıdaki gibi bir şey yazabilirsiniz.

@Test
public void testPrivateMemberMethodCalled() {
    A a = new A();
    SomeOtherClass someOtherClass = Mockito.spy(new SomeOtherClass());
    ReflectionTestUtils.setField( a, "someOtherClass", someOtherClass);
    a.method( true );

    Mockito.verify( someOtherClass, Mockito.times( 1 ) ).method1();
}

ReflectionTestUtils.setField(); özel üyeyi casusluk yapabileceğiniz bir şeyle boğacaktır.

Testinizi aynı pakete, ancak farklı bir kaynak klasöre koyun (src / main / java vs. src / test / java) ve bu yöntemleri paket-özel hale getirin. Imo test edilebilirliği gizlilikten daha önemlidir.

Özel yöntemin geçersiz olmadığı ve dönüş değerinin harici bir bağımlılığın yöntemine bir parametre olarak kullanıldığı durumlarda, bağımlılıkla alay edebilir ArgumentCaptorve dönüş değerini yakalamak için bir kullanabilirsiniz . Örneğin:

ArgumentCaptor<ByteArrayOutputStream> csvOutputCaptor = ArgumentCaptor.forClass(ByteArrayOutputStream.class);
//Do your thing..
verify(this.awsService).uploadFile(csvOutputCaptor.capture());
....
assertEquals(csvOutputCaptor.getValue().toString(), "blabla");