ลองจับในการทดสอบ JUnit

เนื่องจาก Exception เป็นข้อยกเว้นที่ถูกตรวจสอบ คุณจึง:

• ต้องจับข้อยกเว้นในคำสั่ง try...catch หรือ
• ประกาศข้อยกเว้นที่จะโยนลงในเมธอดนั้นเอง

สิ่งที่คุณมีอยู่นั้นใช้ได้ดี แต่ความชอบส่วนตัวของฉันคือการประกาศข้อยกเว้นที่จะถูกโยนออกไป ด้วยวิธีนี้ หากมีข้อยกเว้นที่ฉันไม่คาดหวังเกิดขึ้นระหว่างการทดสอบ การทดสอบจะล้มเหลว

@Test
public void someTest() throws Exception {
    // dodgy code here
}

หากเราต้องการดูว่ามีข้อยกเว้นเฉพาะเจาะจงเกิดขึ้นหรือไม่ คุณมีตัวเลือกในการใช้ @Rule หรือเพิ่มค่าให้กับคำอธิบายประกอบ @Test โดยตรง

@Test(expected = FileNotFoundException.class)
public void someTest() throws Exception {
    // dodgy code here
}

ใน JUnit 5 คุณสามารถใช้ประโยชน์จาก Assertions.assertThrows เพื่อทำสิ่งเดียวกันให้สำเร็จ ฉันไม่ค่อยคุ้นเคยกับสิ่งนี้โดยรวมเนื่องจากยังไม่ได้ GA ในขณะที่แก้ไข แต่ดูเหมือนว่าจะยอมรับ Executable ที่มาจาก JUnit 5

@Test
public void someTest() {
    assertThrows(FileNotFoundException.class, () ->
         { dodgyService.breakableMethod() };
}

@Test
public void someTest() {
   try {
     someMethod();
   }
   catch (Exception e) {
     Assert.fail("Exception " + e);
   }
}

เป็นสิ่งที่คุณสามารถทำได้หากไม่ควรเกิดข้อยกเว้น อีกทางเลือกหนึ่งคือการโยนข้อยกเว้นในลายเซ็นดังนี้:

@Test
public void someTest() throws Exception {
     someMethod();
}

ความแตกต่างก็คือ ในกรณีหนึ่งการทดสอบจะล้มเหลวโดยมีข้อยกเว้นในการยืนยัน และอีกกรณีหนึ่งจะล้มเหลวเนื่องจากการทดสอบล้มเหลว (เช่นที่ไหนสักแห่งในรหัสของคุณที่คุณได้รับ NPE และการทดสอบจะเป็นเช่นนั้น)

เหตุผลที่คุณต้องทำเช่นนี้ เนื่องจาก Exception เป็นข้อยกเว้นที่ถูกตรวจสอบ ดูตรวจสอบแล้วกับข้อยกเว้นที่ไม่ได้ตรวจสอบ

@Test(expected=Exception.class) ใช้สำหรับการทดสอบที่ต้องการทดสอบว่าข้อยกเว้นจะถูกส่งออกไป

@Test(expected=ArrayIndexOutOfBounds.class)
public void testIndex() {
   int[] array = new int[0];
   int var = array[0]; //exception will be thrown here, but test will be green, because we expect this exception

}

อย่าจับข้อยกเว้นของแอปพลิเคชันของคุณในโค้ดทดสอบของคุณ ให้ประกาศให้โยนขึ้นไปแทน

เพราะเมื่อ TestRunner ของ JUnit พบข้อยกเว้นที่ถูกโยนทิ้ง มันจะบันทึกเป็น error สำหรับกรณีทดสอบโดยอัตโนมัติ

เฉพาะในกรณีที่คุณ testcase คาดว่าเมธอดควรส่ง Exception คุณควรใช้ @Test(expected=Exception.class) หรือจับข้อยกเว้น

ในกรณีอื่น ๆ เพียงแค่โยนมันขึ้นไปด้วย

public void someTest() throws Exception {

คุณสามารถเพิ่มข้อยกเว้นในลายเซ็นวิธีทดสอบได้ จากนั้น หากคุณกำลังทดสอบว่ามีข้อยกเว้นเกิดขึ้นหรือไม่ คุณต้องใช้ @Test(expected=Exception.class) ในกรณีที่ทดสอบซึ่งไม่ต้องส่งข้อยกเว้น การทดสอบจะผ่านไปได้สำเร็จ

@Test
public void testCaseWhereExceptionWontBeThrown() throws Exception {
    someMethod(); //Test pass
}

@Test(expected = Exception.class)
public void testCaseWhereExceptionWillBeThrown() throws Exception {
    someMethod(); //Test pass
}

มีกฎหลักสองข้อเกี่ยวกับวิธีการประมวลผลข้อยกเว้นสำหรับผู้ทดสอบ Junit:

1. หากข้อยกเว้นเกิดขึ้นในโค้ดที่ทดสอบ:

   • If it was expected, declare it in the expected attribute of the Test annotation. Or, if further checks should be done on the exception object itself, catch it and ignore it. (In this case, there must be also a call to Assert.fail at the end of the try block, to indicate that the expected exception was not produced).
   • หากไม่เป็นไปตามที่คาดหวัง ให้จับมันแล้วดำเนินการ Assert.fail (การเรียก Exception.printStackTrace ก่อนหน้านี้ก็มีประโยชน์เช่นกัน)

2. หากข้อยกเว้นไม่ได้เกิดขึ้นในโค้ดที่ทดสอบหรือไม่น่าสนใจสำหรับการทดสอบ (เช่น IOException ส่วนใหญ่ถูกสร้างขึ้นที่ระดับเครือข่าย ก่อนที่การทดสอบจะเสร็จสมบูรณ์) ให้โยนใหม่ ที่ส่วนคำสั่ง throws

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

สามประเด็นเกี่ยวกับ JUnit:

• การทดสอบควรมีความแม่นยำ ควรผ่านหรือไม่ผ่านโดยไม่คลุมเครือโดยพิจารณาจากวิธีการตั้งค่าอินพุตการทดสอบเพียงอย่างเดียว

• การทดสอบควรมีการรายงานความล้มเหลวกลับเข้าสู่เฟรมเวิร์ก

• การทดสอบไม่ควรอาศัยการอ่านเอาต์พุต

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

JUnit ได้รับการออกแบบมาเพื่อให้การทำสิ่งที่ถูกต้องเป็นเรื่องง่ายและให้ข้อเสนอแนะที่เป็นประโยชน์แก่นักพัฒนา หากข้อยกเว้นถูกส่งออกมาจากวิธีทดสอบ เฟรมเวิร์กจะตรวจจับข้อยกเว้นนั้นได้ หากการทดสอบมีคำอธิบายประกอบพร้อมข้อยกเว้นที่ระบุว่าคาดว่าจะมีข้อยกเว้น กรอบงานจะทำเครื่องหมายการทดสอบว่าผ่าน มิฉะนั้นเฟรมเวิร์กไม่ผ่านการทดสอบและบันทึกสแต็กเทรซสำหรับการรายงาน กรอบงานจะรายงานว่าการยืนยันใดล้มเหลวและมีข้อยกเว้นที่ไม่คาดคิดเกิดขึ้น เพื่อให้ทุกคนทราบว่าการทดสอบได้ผลหรือไม่

หากคุณคาดหวังว่าการทดสอบจะสำเร็จโดยไม่เกิดข้อยกเว้น หากมีสิ่งใดในการทดสอบที่สามารถทำให้เกิดข้อยกเว้นที่เลือกได้ ให้เพิ่ม throws Exception ลงในลายเซ็นวิธีทดสอบ การเพิ่ม throws ลงในลายเซ็นไม่ได้บอกว่าวิธีการที่ ต้อง โยนสิ่งใด เพียงปล่อยให้ข้อยกเว้นใดๆ ที่เกิดขึ้นเกิดขึ้นถูกโยนออกไป เพื่อให้กรอบงานการทดสอบสามารถตรวจจับได้

อินสแตนซ์เดียวที่คุณจะตรวจจับข้อยกเว้นในการทดสอบได้จริงคือที่ที่คุณต้องการทดสอบการยืนยันเกี่ยวกับข้อยกเว้น ตัวอย่างเช่น คุณสามารถทดสอบว่าข้อความบนข้อยกเว้นนั้นเป็นสิ่งที่คุณคาดหวัง หรือถ้าข้อยกเว้นนั้นมีสาเหตุอยู่ ในกรณีนั้น คุณจะต้องเพิ่ม Assert.fail() ที่ส่วนท้ายของ try-block เพื่อไม่ให้มีข้อยกเว้นเกิดขึ้นจะทำให้การทดสอบล้มเหลว

ไม่มีบล็อก try-catch ที่ไม่ดีนัก แต่ไม่มีสิ่งใดที่จะทำให้การทดสอบล้มเหลวที่ไม่ดี

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

มีข้อยกเว้นประการใด? ใช่ไหม

1. ข้อยกเว้นจากการทำบางอย่างเช่นการใช้สตรีมที่จะไม่เกิดขึ้นในการทดสอบหน่วยของคุณหรือ
2. ข้อยกเว้นที่อาจเกิดขึ้นเนื่องจากการป้อนข้อมูลที่ไม่ดีบางประเภท

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

@Test
public void testFoo() throws Exception {
    // ...
}

ถ้าเป็น 2. มันจะซับซ้อนขึ้นอีกหน่อย คุณต้องถามตัวเองว่าจะเกิดอะไรขึ้นหากข้อยกเว้นถูกส่งออกไป การทดสอบควรล้มเหลวหรือไม่? เป็นไปตามคาดหรือเปล่า? มันไม่เกี่ยวข้องเหรอ? ตัวอย่างวิธีจัดการสิ่งเหล่านี้ด้านล่าง ระวัง: ฉันใช้ข้อยกเว้นเพียงเพราะคุณใช้ ฉันหวังว่ามันจะไม่เป็นเช่นนั้นจริงๆ เพราะหากเป็นไปได้ที่ข้อยกเว้น other บางอย่างจะถูกโยนทิ้งไปนอกเหนือจากที่คาดไว้ สิ่งเหล่านี้ก็จะเกะกะมาก ถ้าเป็นไปได้ อย่าใช้ Exception ให้ใช้คำที่เฉพาะเจาะจงกว่านี้ (ในโค้ด และ มิถุนายน)

// The below code assumes you've imported the org.junit.Assert class.

@Test
public void thisShouldFailIfExceptionCaught() {
    //Given...
    try {
        // When...
    } catch (Exception e) {
        Assert.fail();
    }
    // Then...
}

@Test
public void thisShouldPassOnlyIfTheExceptionIsCaught() {
    //Given...
    try {
        // When...
        Assert.fail();
    } catch (Exception expected) {}
    // No "then" needed, the fact that it didn't fail is enough.
}

@Test
public void irrelevantExceptionThatCouldBeThrown() {
    //Given...
    try {
        // When...
    } catch (Exception e) {}
    // Then...
}