Попробуйте поймать в тесте 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

}

Не перехватывайте исключение вашего приложения в тестовом коде. Вместо этого объявите, что он подброшен вверх.

Потому что, когда JUnit TestRunner находит выброшенное исключение, он автоматически регистрирует его как 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. Если исключение не было создано в тестируемом коде или оно не представляет интереса для теста (например, большинство исключений ввода-вывода создаются на сетевом уровне еще до того, как тест может быть даже завершен), повторите его. в пункте throws.

Почему вы должны ожидать исключения в тестере? Напоминаем: вы должны написать один тестовый метод для каждого возможного результата в тестируемом коде (для достижения высокого покрытия кода): в вашем случае один метод должен возвращаться успешно, и по крайней мере еще один это должно привести к исключению.

Три момента о JUnit:

• Тесты должны быть точными, они должны быть однозначно пройдены или не пройдены исключительно в зависимости от того, как настроены тестовые входные данные.

• Тесты должны сообщать об ошибках обратно в фреймворк.

• Тесты не должны полагаться на чтение их вывода.

Ваш пример не работает по всем трем пунктам. Если возникнет исключение или нет, тест все равно будет пройден. Если возникает исключение, JUnit никогда не узнает об этом и не может включить его в результаты теста. Единственный способ узнать, что что-то пошло не так, — это прочитать, что тест записывает в стандартный вывод, из-за чего ошибки слишком легко игнорировать. Это не очень удобный способ написания тестов.

JUnit был разработан, чтобы упростить выполнение правильных действий и дать разработчикам полезную обратную связь. Если из тестового метода выбрасывается исключение, оно перехватывается фреймворком. Если тест был помечен исключением, указывающим, что ожидается исключение, то платформа помечает тест как пройденный. В противном случае платформа не проходит тест и записывает трассировку стека для отчетности. Фреймворк сообщает, какие утверждения терпят неудачу и какие неожиданные исключения произошли, чтобы все знали, сработали ли тесты или нет.

Если вы ожидаете, что тест завершится успешно без создания исключения, тогда, если что-либо в тесте может вызвать проверенное исключение, добавьте throws Exception к сигнатуре метода тестирования. Добавление throws к сигнатуре не означает, что метод должен что-либо генерировать, он просто позволяет генерировать любые возникающие исключения, чтобы среда тестирования могла их перехватить.

Единственный случай, когда вы действительно поймаете исключение в тесте, — это когда вы хотите проверить утверждения об исключении; например, вы можете проверить, соответствует ли сообщение об исключении тому, что вы ожидаете, или если для исключения установлена ​​причина. В этом случае вы должны добавить Assert.fail() в конец блока try, чтобы отсутствие исключения привело к сбою теста.

Плохо не наличие блока try-catch, а отсутствие чего-либо, что может привести к сбою теста.

Когда вы сначала пишете тест, сделайте так, чтобы он провалился. Таким образом вы доказываете себе, что знаете, что делает тест, и подтверждаете, что в случае сбоя вы будете об этом осведомлены.

Что это за исключение? Это

1. исключение из выполнения чего-то вроде использования потоков, которые не будут происходить в вашем модульном тесте или
2. исключение, которое может произойти из-за какого-то неправильного ввода?

Если это 1. Я бы просто поместил его на уровень сигнатуры метода, потому что try-catch не служит никакой реальной цели, кроме церемонии.

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

Если это 2. это становится немного сложнее. Вы должны спросить себя, что должно происходить, если выдается исключение. Должен ли тест провалиться? Это ожидается? Это не имеет значения? Примеры ниже того, как справиться со всем этим. ВНИМАНИЕ: я использовал Exception только потому, что это сделали вы. Я надеюсь, что на самом деле это не так, потому что, если какое-то другое исключение может быть выброшено, отличное от ожидаемого, то это будет очень шатко. Если возможно, не используйте Exception, используйте что-то более конкретное (в коде junit и).

// 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...
}