ฉันรู้ว่าวิธีหนึ่งที่จะทำได้:

@Test
public void foo(){
   try{
      //execute code that you expect not to throw Exceptions.
   }
   catch(Exception e){
      fail("Should not have thrown any exception");
   }
}

มีวิธีใดที่สะอาดกว่าในการทำสิ่งนี้ (อาจใช้ Junit @Ruleหรือไม่?)

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

ฉันสังเกตเห็นคำถามนี้ได้รับความสนใจเป็นครั้งคราวดังนั้นฉันจะขยายตัวเล็กน้อย

ความเป็นมาของการทดสอบหน่วย

เมื่อคุณทดสอบหน่วยสิ่งสำคัญคือการกำหนดสิ่งที่คุณควรพิจารณาในหน่วยงาน โดยทั่วไป: การแยก codebase ของคุณที่อาจมีหรือไม่มีหลายวิธีหรือคลาสที่แสดงถึงการทำงานเพียงส่วนเดียว

หรือตามที่กำหนดไว้ในศิลปะการทดสอบหน่วยรุ่นที่ 2 โดย Roy Osheroveหน้า 11:

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

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

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

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

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

การจัดการอินพุตที่ถูกต้องและผิดพลาดของการทดสอบ

ณ จุดนี้มันควรจะชัดเจนว่าเราจะจัดการกับข้อยกเว้นเหล่านี้ได้อย่างไร อินพุตมี 2 ประเภท: อินพุตที่ถูกต้องและอินพุตที่ผิดพลาด (อินพุตนั้นถูกต้องในความหมายที่เข้มงวด แต่ไม่ถูกต้อง)

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

existingUserById_ShouldReturn_UserObjectเรียกวิธีดังกล่าวสามารถมีลักษณะเช่นนี้ หากวิธีนี้ล้มเหลว (เช่น: มีข้อผิดพลาดเกิดขึ้น) คุณจะรู้ว่ามีบางอย่างผิดปกติและคุณสามารถเริ่มขุดได้

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

TL; DR

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

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

ฉันสะดุดกับสิ่งนี้เนื่องจากกฎของ SonarQube "squid: S2699": "เพิ่มการยืนยันอย่างน้อยหนึ่งกรณีในการทดสอบนี้"

ฉันมีการทดสอบอย่างง่าย ๆ โดยมีเป้าหมายเพียงอย่างเดียวที่ต้องทำโดยไม่ต้องทำการยกเว้นข้อยกเว้น

พิจารณารหัสง่าย ๆ นี้:

public class Printer {

    public static void printLine(final String line) {
        System.out.println(line);
    }
}

คุณสามารถเพิ่มการยืนยันประเภทใดในการทดสอบวิธีนี้ แน่นอนว่าคุณสามารถลองดูได้ แต่นั่นเป็นเพียงโค้ดขยายตัว

การแก้ปัญหามาจาก JUnit เอง

ในกรณีที่ไม่มีข้อยกเว้นและคุณต้องการแสดงให้เห็นถึงพฤติกรรมนี้อย่างชัดเจนเพียงเพิ่มexpectedดังตัวอย่างต่อไปนี้:

@Test(expected = Test.None.class /* no exception expected */)
public void test_printLine() {
    Printer.printLine("line");
}

Test.None.class เป็นค่าเริ่มต้นสำหรับค่าที่คาดหวัง

ด้วยAssertJ ได้อย่างคล่องแคล่วยืนยัน 3.7.0 :

Assertions.assertThatCode(() -> toTest.method())
    .doesNotThrowAnyException();

JUnit 5 (จูปิเตอร์) มีสามฟังก์ชันเพื่อตรวจสอบว่ามี / ไม่มีข้อยกเว้น:

● assertAll​()

  ยืนยันว่าสิ่งที่ให้มาทั้งหมดexecutables
  จะไม่ส่งข้อยกเว้น

● assertDoesNotThrow​()

  ยืนยันการดำเนินการของที่
  ให้มาด้วยexecutable/ supplier
  ไม่เคยโยนชนิดใดมีข้อยกเว้น

  ฟังก์ชันนี้ใช้งานได้
  ตั้งแต่JUnit 5.2.0 (29 เมษายน 2018)

● assertThrows​()

  ยืนยันการดำเนินการของที่จัดว่าexecutable
  โยนข้อยกเว้นของexpectedType
  และส่งกลับข้อยกเว้น

ตัวอย่าง

package test.mycompany.myapp.mymodule;

import static org.junit.jupiter.api.Assertions.*;

import org.junit.jupiter.api.Test;

class MyClassTest {

    @Test
    void when_string_has_been_constructed_then_myFunction_does_not_throw() {
        String myString = "this string has been constructed";
        assertAll(() -> MyClass.myFunction(myString));
    }

    @Test
    void when_string_has_been_constructed_then_myFunction_does_not_throw__junit_v520() {
        String myString = "this string has been constructed";
        assertDoesNotThrow(() -> MyClass.myFunction(myString));
    }

    @Test
    void when_string_is_null_then_myFunction_throws_IllegalArgumentException() {
        String myString = null;
        assertThrows(
            IllegalArgumentException.class,
            () -> MyClass.myFunction(myString));
    }

}

Java 8 ทำให้สิ่งนี้ง่ายขึ้นมากและ Kotlin / Scala เพิ่มขึ้นเป็นสองเท่า

เราสามารถเขียนคลาสอรรถประโยชน์เล็กน้อย

class MyAssertions{
  public static void assertDoesNotThrow(FailingRunnable action){
    try{
      action.run()
    }
    catch(Exception ex){
      throw new Error("expected action not to throw, but it did!", ex)
    }
  }
}

@FunctionalInterface interface FailingRunnable { void run() throws Exception }

จากนั้นรหัสของคุณจะกลายเป็น:

@Test
public void foo(){
  MyAssertions.assertDoesNotThrow(() -> {
    //execute code that you expect not to throw Exceptions.
  }
}

หากคุณไม่มีสิทธิ์เข้าถึง Java-8 ฉันจะใช้สิ่งอำนวยความสะดวก java แบบเก่าที่เจ็บปวด: บล็อกโค้ดแบบอาริบิทและความคิดเห็นง่าย ๆ

//setup
Component component = new Component();

//act
configure(component);

//assert 
/*assert does not throw*/{
  component.doSomething();
}

และสุดท้ายด้วย kotlin ภาษาที่ฉันเพิ่งตกหลุมรัก:

fun (() -> Any?).shouldNotThrow() 
    = try { invoke() } catch (ex : Exception){ throw Error("expected not to throw!", ex) }

@Test fun `when foo happens should not throw`(){

  //...

  { /*code that shouldn't throw*/ }.shouldNotThrow()
}

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

เกี่ยวกับ

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

หลักการนี้ถูกต้อง แต่สรุปไม่ถูกต้อง

Java อนุญาตให้มีข้อยกเว้นสำหรับการไหลของการควบคุม นี้จะกระทำโดยรันไทม์ JRE ตัวเองใน APIs เช่นDouble.parseDoubleผ่านNumberFormatExceptionและผ่านPaths.getInvalidPathException

เมื่อคุณเขียนส่วนประกอบที่ตรวจสอบความถูกต้องของ Number Number Double.ParseDoubleอาจใช้ Regex หรือ parser ที่เขียนด้วยมือหรืออาจเป็นสิ่งที่ฝังกฏโดเมนอื่น ๆ ที่ จำกัด ช่วงของ double เป็นสิ่งที่เฉพาะเจาะจงวิธีที่ดีที่สุดในการทดสอบนี้ องค์ประกอบ? ฉันคิดว่าการทดสอบที่ชัดเจนจะยืนยันว่าเมื่อแยกสตริงผลลัพธ์ออกแล้วจะไม่มีข้อยกเว้นเกิดขึ้น ฉันจะเขียนการทดสอบโดยใช้ด้านบนassertDoesNotThrowหรือ/*comment*/{code}บล็อก สิ่งที่ต้องการ

@Test public void given_validator_accepts_string_result_should_be_interpretable_by_doubleParseDouble(){
  //setup
  String input = "12.34E+26" //a string double with domain significance

  //act
  boolean isValid = component.validate(input)

  //assert -- using the library 'assertJ', my personal favourite 
  assertThat(isValid).describedAs(input + " was considered valid by component").isTrue();
  assertDoesNotThrow(() -> Double.parseDouble(input));
}

ฉันขอแนะนำให้คุณกำหนดพารามิเตอร์การทดสอบนี้inputโดยใช้TheoriesหรือParameterizedเพื่อให้คุณได้ง่ายขึ้นสามารถกลับมาใช้การทดสอบนี้สำหรับปัจจัยการผลิตอื่น ๆ อีกทางเลือกหนึ่งถ้าคุณต้องการแปลกใหม่คุณสามารถใช้เครื่องมือทดสอบรุ่น (และสิ่งนี้ ) TestNG ได้รับการสนับสนุนที่ดีกว่าสำหรับการทดสอบแบบกำหนดพารามิเตอร์

สิ่งที่ฉันพบไม่พอใจโดยเฉพาะอย่างยิ่งเป็นคำแนะนำในการใช้@Test(expectedException=IllegalArgumentException.class), ข้อยกเว้นนี้เป็นอันตรายในวงกว้าง หากรหัสของคุณเปลี่ยนแปลงเช่นนั้นองค์ประกอบภายใต้ตัวสร้างของการทดสอบมีif(constructorArgument <= 0) throw IllegalArgumentException()และการทดสอบของคุณจัดหา 0 สำหรับอาร์กิวเมนต์นั้นเพราะสะดวก - และนี่เป็นเรื่องธรรมดามากเพราะข้อมูลทดสอบที่สร้างดีนั้นเป็นปัญหาที่ยากอย่างน่าประหลาดใจ - จากนั้นการทดสอบของคุณ จะเป็นแถบสีเขียวแม้ว่าจะไม่ได้ทดสอบอะไรเลย การทดสอบดังกล่าวแย่กว่าไร้ประโยชน์

หากคุณโชคไม่ดีที่พบข้อผิดพลาดทั้งหมดในรหัสของคุณ คุณสามารถทำอย่างโง่เขลา

class DumpTest {
    Exception ex;
    @Test
    public void testWhatEver() {
        try {
            thisShouldThrowError();
        } catch (Exception e) {
            ex = e;
        }
        assertEquals(null,ex);
    }
}

JUnit5 เพิ่มเมธอด assertAll () เพื่อวัตถุประสงค์ที่แน่นอนนี้

assertAll( () -> foo() )

แหล่งที่มา: JUnit 5 API

แม้ว่าโพสต์นี้จะมีอายุ 6 ปีแล้ว แต่มีการเปลี่ยนแปลงมากมายในโลก Junit ด้วย Junit5 คุณสามารถใช้งานได้แล้ว

org.junit.jupiter.api.Assertions.assertDoesNotThrow()

Ex:

public void thisMethodDoesNotThrowException(){
   System.out.println("Hello There");
}

@Test
public void test_thisMethodDoesNotThrowException(){
  org.junit.jupiter.api.Assertions.assertDoesNotThrow(
      ()-> thisMethodDoesNotThrowException()
    );
}

หวังว่ามันจะช่วยให้ผู้ที่ใช้ Junit5 รุ่นใหม่

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

@Test
public void consumesAndLogsExceptions() throws Exception {

    context.checking(new Expectations() {
        {
            oneOf(collaborator).doSth();
            will(throwException(new NullPointerException()));
        }
    });

    target.doSth();
 }

การทดสอบจะผ่านหากเป้าหมายของคุณใช้ข้อยกเว้นเกิดขึ้นมิฉะนั้นการทดสอบจะล้มเหลว

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

@Test
public void consumesAndLogsExceptions() throws Exception {
    Exception e = new NullPointerException();
    context.checking(new Expectations() {
        {
            allowing(collaborator).doSth();
            will(throwException(e));

            oneOf(consumer).consume(e);
        }
    });

    target.doSth();
 }

แต่บางครั้งมันถูกออกแบบมามากเกินไปหากคุณต้องการเข้าสู่ระบบ ในกรณีนี้บทความนี้ ( http://java.dzone.com/articles/monitoring-declarative-transac , http://blog.novoj.net/2008/09/20/testing-aspect-pointcuts-is-there -an-easy-way / ) อาจช่วยได้หากคุณยืนยัน tdd ในกรณีนี้

ใช้assertNull (... )

@Test
public void foo() {
    try {
        //execute code that you expect not to throw Exceptions.
    } catch (Exception e){
        assertNull(e);
    }
}

คุณสามารถคาดหวังได้ว่าข้อยกเว้นจะไม่ถูกส่งออกไปโดยการสร้างกฎ

@Rule
public ExpectedException expectedException = ExpectedException.none();

นี่อาจไม่ใช่วิธีที่ดีที่สุด แต่แน่นอนว่าทำให้แน่ใจว่าไม่มีการยกเว้นจากการบล็อกโค้ดที่กำลังทดสอบ

import org.assertj.core.api.Assertions;
import org.junit.Test;

public class AssertionExample {

    @Test
    public void testNoException(){
        assertNoException();
    }    

    private void assertException(){
        Assertions.assertThatThrownBy(this::doNotThrowException).isInstanceOf(Exception.class);
    }

    private void assertNoException(){
        Assertions.assertThatThrownBy(() -> assertException()).isInstanceOf(AssertionError.class);
    }

    private void doNotThrowException(){
        //This method will never throw exception
    }
}

คุณสามารถทำได้โดยใช้ @Rule แล้วเรียกวิธีการ reportMissingExceptionWithMessage ดังที่แสดงด้านล่าง: นี่คือรหัสสกาล่า

การทดสอบต่อไปนี้ล้มเหลวสำหรับข้อยกเว้นทั้งหมดทำเครื่องหมายหรือไม่เลือก:

@Test
public void testMyCode() {

    try {
        runMyTestCode();
    } catch (Throwable t) {
        throw new Error("fail!");
    }
}

คุณสามารถสร้างการยืนยันของคุณเองใด ๆ ขึ้นอยู่กับการยืนยันจาก junit:

static void assertDoesNotThrow(Executable executable) {
    assertDoesNotThrow(executable, "must not throw");
}
static void assertDoesNotThrow(Executable executable, String message) {
    try {
        executable.execute();
    } catch (Throwable err) {
        fail(message);
    }
}

และทดสอบ:

//the following will succeed
assertDoesNotThrow(()->methodMustNotThrow(1));
assertDoesNotThrow(()->methodMustNotThrow(1), "fail with specific message: facepalm");
//the following will fail
assertDoesNotThrow(()->methodMustNotThrow(2));
assertDoesNotThrow(()-> {throw new Exception("Hello world");}, "Fail: must not trow");

โดยทั่วไปการพูดมีความเป็นไปได้ที่จะล้มเหลวทันที ("bla bla bla") การทดสอบในทุกสถานการณ์ในทุกสถานที่ที่เหมาะสม ตัวอย่างเช่นใช้ในบล็อกลอง / จับเพื่อล้มเหลวหากมีอะไรโยนในกรณีทดสอบ:

try{methodMustNotThrow(1);}catch(Throwable e){fail("must not throw");}
//or
try{methodMustNotThrow(1);}catch(Throwable e){Assertions.fail("must not throw");}

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

void methodMustNotThrow(int x) throws Exception{
    if (x == 1) return;
    throw new Exception();
}

วิธีการดังกล่าวเป็นตัวอย่างง่ายๆ แต่สิ่งนี้ใช้ได้กับสถานการณ์ที่ซับซ้อนซึ่งความล้มเหลวไม่ชัดเจนนัก มีการนำเข้า:

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.function.Executable;
import static org.junit.jupiter.api.Assertions.*;