การทดสอบวิธีการส่วนตัวโดยใช้ mockito

ชั้นสาธารณะ A {

    วิธีโมฆะสาธารณะ (บูลีน b) {
          ถ้า (b == จริง)
               วิธีที่ 1 ();
          อื่น
               วิธีที่ 2 ();
    }

    โมฆะส่วนตัว method1 () {}
    โมฆะส่วนตัว method2 () {}
}

ชั้นเรียนสาธารณะ TestA {

    @ทดสอบ
    โมฆะสาธารณะ testMethod () {
      a = เยาะเย้ย (A.class);
      ก. วิธีการ (จริง);
      // วิธีการทดสอบเช่นตรวจสอบ (a) .method1 ();
    }
}

วิธีการทดสอบ private method เรียกว่าอย่างไรหรือไม่และจะทดสอบ private method โดยใช้ mockito ได้อย่างไร ???

คุณไม่สามารถทำได้ด้วย Mockito แต่คุณสามารถใช้Powermockเพื่อขยาย Mockito และล้อเลียนวิธีการส่วนตัว Powermock รองรับ Mockito นี่คือตัวอย่าง

ไม่สามารถทำได้ผ่านทาง mockito จากวิกิของพวกเขา

ทำไม Mockito ไม่ล้อเลียนวิธีการส่วนตัว?

ประการแรกเราไม่ดันทุรังที่จะล้อเลียนวิธีการส่วนตัว เราไม่สนใจเมธอดส่วนตัวเพราะจากมุมมองของการทดสอบเมธอดส่วนตัวไม่มีอยู่จริง นี่คือเหตุผลสองสามประการที่ Mockito ไม่ล้อเลียนวิธีการส่วนตัว:

ต้องมีการแฮ็ก classloaders ที่ไม่มีสัญลักษณ์แสดงหัวข้อย่อยและเปลี่ยน api (คุณต้องใช้ตัวทดสอบที่กำหนดเองใส่คำอธิบายประกอบคลาส ฯลฯ )

มันง่ายมากที่จะแก้ไข - เพียงแค่เปลี่ยนการเปิดเผยวิธีการจากส่วนตัวเป็นการป้องกันด้วยแพ็กเกจ (หรือป้องกัน)

ฉันต้องใช้เวลาในการใช้งานและบำรุงรักษา และมันไม่สมเหตุสมผลที่ให้จุด # 2 และความจริงที่ว่ามันถูกนำไปใช้แล้วในเครื่องมือที่แตกต่างกัน (powermock)

สุดท้าย ... การล้อเลียนวิธีส่วนตัวเป็นการบอกใบ้ว่ามีบางอย่างผิดปกติกับความเข้าใจของ OO ใน OO คุณต้องการให้วัตถุ (หรือบทบาท) ทำงานร่วมกันไม่ใช่วิธีการ ลืมรหัสปาสคาลและขั้นตอน คิดในวัตถุ

นี่คือตัวอย่างเล็ก ๆ น้อย ๆ ในการใช้งานpowermock

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

ในการทดสอบmethod1 ให้ใช้รหัส:

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

ในการตั้งค่าวัตถุส่วนตัวobj ให้ใช้สิ่งนี้:

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

คิดเกี่ยวกับเรื่องนี้ในแง่ของพฤติกรรมไม่ใช่ในแง่ของวิธีการที่มี วิธีการที่เรียกว่าmethodมีพฤติกรรมเฉพาะถ้าbเป็นจริง มันมีพฤติกรรมที่แตกต่างกันหากbเป็นเท็จ ซึ่งหมายความว่าคุณควรจะเขียนทั้งสองแตกต่างกันสำหรับการทดสอบmethod; หนึ่งสำหรับแต่ละกรณี ดังนั้นแทนที่จะมีการทดสอบเชิงวิธีการสามแบบ (หนึ่งสำหรับmethodหนึ่งสำหรับmethod1หนึ่งสำหรับmethod2คุณมีการทดสอบเชิงพฤติกรรมสองแบบ

ที่เกี่ยวข้องกับสิ่งนี้ (ฉันแนะนำสิ่งนี้ในเธรด SO อื่นเมื่อเร็ว ๆ นี้และได้รับการเรียกว่าคำสี่ตัวอักษรดังนั้นอย่าลังเลที่จะใช้สิ่งนี้กับเกลือหนึ่งเม็ด) ฉันคิดว่าการเลือกชื่อการทดสอบที่แสดงถึงพฤติกรรมที่ฉันกำลังทดสอบนั้นเป็นประโยชน์มากกว่าชื่อของวิธีการ จึงไม่เรียกการทดสอบของคุณtestMethod(), testMethod1(), testMethod2()และอื่น ๆ ฉันชอบชื่อที่เหมือนcalculatedPriceIsBasePricePlusTax()หรือtaxIsExcludedWhenExcludeIsTrue()บ่งบอกถึงพฤติกรรมที่ฉันกำลังทดสอบ จากนั้นในแต่ละวิธีทดสอบให้ทดสอบเฉพาะพฤติกรรมที่ระบุ พฤติกรรมดังกล่าวส่วนใหญ่จะเกี่ยวข้องกับการเรียกใช้วิธีการสาธารณะเพียงครั้งเดียว แต่อาจเกี่ยวข้องกับการเรียกใช้วิธีการส่วนตัวหลายครั้ง

หวังว่านี่จะช่วยได้

ในขณะที่ Mockito ไม่ได้ให้ความสามารถในการที่คุณจะได้บรรลุผลเดียวกันโดยใช้ Mockito + ระดับ JUnit ReflectionUtils หรือฤดูใบไม้ผลิReflectionTestUtilsระดับ โปรดดูตัวอย่างด้านล่างที่นำมาจากที่นี่เพื่ออธิบายวิธีเรียกใช้เมธอดส่วนตัว:

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

ตัวอย่างที่สมบูรณ์ด้วย ReflectionTestUtils และ Mockito สามารถพบได้ในหนังสือMockito for Spring

คุณไม่ควรทดสอบวิธีการส่วนตัว ต้องมีการทดสอบเฉพาะวิธีที่ไม่เป็นส่วนตัวเท่านั้นเนื่องจากควรเรียกวิธีการส่วนตัว หากคุณ "ต้องการ" ทดสอบวิธีการส่วนตัวอาจบ่งชี้ว่าคุณต้องทบทวนการออกแบบของคุณใหม่:

ฉันใช้การฉีดพึ่งพาที่เหมาะสมหรือไม่? ฉันอาจจำเป็นต้องย้ายเมธอดส่วนตัวไปยังคลาสแยกต่างหากและทำการทดสอบหรือไม่ วิธีการเหล่านี้ต้องเป็นแบบส่วนตัวหรือไม่? ... ไม่สามารถผิดนัดหรือป้องกันได้หรือ

ในตัวอย่างข้างต้นวิธีการทั้งสองที่เรียกว่า "สุ่ม" อาจจำเป็นต้องวางไว้ในคลาสของตนเองทดสอบแล้วจึงฉีดเข้าไปในคลาสด้านบน

ฉันสามารถทดสอบวิธีการส่วนตัวภายในโดยใช้ม็อกโตโต้โดยใช้การสะท้อน นี่คือตัวอย่างพยายามตั้งชื่อให้มันเข้าท่า

//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));

1. โดยการใช้การสะท้อนสามารถเรียกวิธีส่วนตัวจากชั้นเรียนทดสอบ ในกรณีนี้,

   // วิธีทดสอบจะเป็นแบบนี้ ...

   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. หากเมธอดส่วนตัวเรียกใช้เมธอดส่วนตัวอื่น ๆ เราจำเป็นต้องสอดแนมวัตถุและขีดฆ่าวิธีอื่นคลาสทดสอบจะเป็นเช่น ...

   // วิธีทดสอบจะเป็นแบบนี้ ...

   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);
   
       }
   }

** แนวทางคือการรวมการสะท้อนและการสอดแนมวัตถุ ** method1 และ ** method2 เป็นเมธอดส่วนตัวและ method1 เรียก method2

ฉันไม่เข้าใจความจำเป็นของคุณในการทดสอบวิธีส่วนตัว ปัญหาหลักคือวิธีสาธารณะของคุณมีโมฆะเป็นประเภทการส่งคืนดังนั้นคุณจึงไม่สามารถทดสอบวิธีสาธารณะของคุณได้ ดังนั้นคุณถูกบังคับให้ทดสอบวิธีการส่วนตัวของคุณ ฉันเดาถูกหรือเปล่า ??

วิธีแก้ปัญหาที่เป็นไปได้บางประการ (AFAIK):

1. ล้อเลียนวิธีการส่วนตัวของคุณ แต่คุณก็ยังไม่ "ทดสอบวิธีการของคุณ" จริง

2. ตรวจสอบสถานะของวัตถุที่ใช้ในวิธีการ เมธอดส่วนใหญ่จะทำการประมวลผลค่าอินพุตและส่งคืนเอาต์พุตหรือเปลี่ยนสถานะของอ็อบเจ็กต์ นอกจากนี้ยังสามารถใช้การทดสอบวัตถุสำหรับสถานะที่ต้องการได้

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

   [ที่นี่คุณสามารถทดสอบเมธอดส่วนตัวได้โดยตรวจสอบการเปลี่ยนสถานะของ classObj จาก null เป็น null]

3. Refactor รหัสของคุณเล็กน้อย (หวังว่านี่จะไม่ใช่รหัสเดิม) ปัจจัยในการเขียนวิธีการของฉันคือเราควรส่งคืนบางสิ่ง (int / a boolean) ค่าที่ส่งคืนอาจหรืออาจจะไม่ถูกใช้โดยการใช้งาน แต่จะถูกใช้โดยการทดสอบอย่างแน่นอน

   รหัส.

   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 จริงๆ สมมติว่าคุณมีคลาสดังนี้:

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.methodจะเรียกใช้วิธีการจากSomeOtherClassคุณสามารถเขียนสิ่งที่ต้องการด้านล่าง

@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(); จะขัดขวางสมาชิกส่วนตัวด้วยสิ่งที่คุณสามารถสอดแนมได้

ใส่การทดสอบของคุณในแพ็คเกจเดียวกัน แต่เป็นโฟลเดอร์ซอร์สที่แตกต่างกัน (src / main / java เทียบกับ src / test / java) และทำให้วิธีการเหล่านั้นเป็นแพ็กเกจส่วนตัว ความสามารถในการทดสอบ Imo สำคัญกว่าความเป็นส่วนตัว

ในกรณีที่เมธอดไพรเวตไม่เป็นโมฆะและใช้ค่าส่งคืนเป็นพารามิเตอร์สำหรับเมธอดของการพึ่งพาภายนอกคุณสามารถเยาะเย้ยการอ้างอิงและใช้ArgumentCaptorเพื่อจับค่าที่ส่งคืน ตัวอย่างเช่น:

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